<!doctype html>
<html lang="en" dir="ltr" class="blog-wrapper blog-post-page plugin-blog plugin-id-default" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.3">
<title data-rh="true">Apache CloudStack Weekly News - 18 March 2013 | Apache CloudStack</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_181"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_tag" content="default"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:docusaurus_tag" content="default"><meta data-rh="true" property="og:title" content="Apache CloudStack Weekly News - 18 March 2013 | Apache CloudStack"><meta data-rh="true" name="description" content="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."><meta data-rh="true" property="og:description" content="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."><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2013-03-18T00:00:00.000Z"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_181"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_181" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/apache_cloudstack_weekly_news_181" hreflang="x-default"><link rel="alternate" type="application/rss+xml" href="/blog/rss.xml" title="Apache CloudStack RSS Feed">
<link rel="alternate" type="application/atom+xml" href="/blog/atom.xml" title="Apache CloudStack Atom Feed">






<script src="scripts/bootstrap.bundle.min.js" async></script><link rel="stylesheet" href="/assets/css/styles.e12efb83.css">
<link rel="preload" href="/assets/js/runtime~main.d78c67af.js" as="script">
<link rel="preload" href="/assets/js/main.8e0276ef.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--dark_i4oU"></div><b class="navbar__title text--truncate"></b></a></div><div class="navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">About</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/about">About</a></li><li><a class="dropdown__link" href="/history">History</a></li><li><a class="dropdown__link" href="/features">Features</a></li><li><a class="dropdown__link" href="/who">Who We Are</a></li><li><a class="dropdown__link" href="/bylaws">Community Bylaws</a></li><li><a class="dropdown__link" href="/trademark-guidelines">Trademark Guidelines</a></li><li><a class="dropdown__link" href="/security">Security</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/contribute">Get Involved</a></li><li><a class="dropdown__link" href="/developers">Developer Resources</a></li><li><a class="dropdown__link" href="/mailing-lists">Join Mailing Lists</a></li><li><a href="https://github.com/apache/cloudstack/issues" target="_blank" rel="noopener noreferrer" class="dropdown__link">Issues Tracker<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-1u8qwbivp-u16HRI~LWioLmF1G2D3Iyg" target="_blank" rel="noopener noreferrer" class="dropdown__link">Community Slack<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/events">Events and Meetups</a></li><li><a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Collab Conference<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Use Cases</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/cloud-builders">Cloud Builders</a></li><li><a class="dropdown__link" href="/kubernetes">Kubernetes</a></li><li><a class="dropdown__link" href="/integrations">Integrations</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Users</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/users">Known Users</a></li><li><a class="dropdown__link" href="/blog/blog/tags/case-studies">Case Studies</a></li><li><a href="https://docs.google.com/forms/d/e/1FAIpQLScPHIRetdt-pxPT62IesXMoQUmhQ8ATGKcYZa507mB9uwzn-Q/viewform" target="_blank" rel="noopener noreferrer" class="dropdown__link">Take Survey<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Documentation</a><ul class="dropdown__menu"><li><a href="https://docs.cloudstack.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Documentation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Home" target="_blank" rel="noopener noreferrer" class="dropdown__link">Project Wiki<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Books<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/api/">API Documentation</a></li></ul></div><a class="navbar__item navbar__link" href="/downloads">Download</a><a class="navbar__item navbar__link" href="/blog">Blog</a><a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link header-github-link" aria-label="GitHub repository"></a><div class="searchBox_ZlJk"><div class="navbar__search searchBarContainer_NW3z"><input placeholder="Search" aria-label="Search" class="navbar__search-input"><div class="loadingRing_RJI3 searchBarLoadingRing_YnHq"><div></div><div></div><div></div><div></div></div><div class="searchHintContainer_Pkmr"><kbd class="searchHint_iIMx">ctrl</kbd><kbd class="searchHint_iIMx">K</kbd></div></div></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">ASF</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation</a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License</a></li><li><a href="https://www.apache.org/events/current-event" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events</a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security</a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship</a></li><li><a href="https://www.apache.org/foundation/policies/privacy.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Privacy</a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks</a></li></ul></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><div class="container margin-vert--lg blog-container"><div class="row"><aside class="col col--3"><nav class="sidebar thin-scrollbar"><div class="sidebarItemTitle margin-bottom--md">CloudStack Blog</div><ul class="sidebarItemList clean-list"><li class="sidebarItem"><a class="sidebarItemLink" href="/blog">All Posts</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/news">News</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/announcement">Announcements</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/roundup">Past Events</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/case-studies">Case Studies &amp; Integrations</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/community">Meet the Community</a></li></ul></nav></aside><main class="col col--7" itemscope="" itemtype="http://schema.org/Blog"><article itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="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."><header><h1 class="title_f1Hy" itemprop="headline">Apache CloudStack Weekly News - 18 March 2013</h1><div class="container_mt6G margin-vert--md"><time datetime="2013-03-18T00:00:00.000Z" itemprop="datePublished">March 18, 2013</time></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><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&#x27;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&#x27;s now up to the Apache Software Foundation board to discuss. The next board meeting is on March 20th, though it&#x27;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&#x27;s made some changes</a> to &quot;help developers with better productivity.&quot; 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>, &quot;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&#x27;s on different VLANs.&quot;</p><p>Stuck on a technical issue? Ask on the -dev list, and it&#x27;s quite likely you&#x27;ll not only get an answer – odds are someone&#x27;s had the problem you&#x27;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, &quot;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.&quot;</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&#x27;s written and talked about CloudStack resources previously, but &quot;while cheerleading and telling people it is awesome should be enough - it really doesn&#x27;t tell you how to actually use it.&quot;</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&#x27;s use of Apache CloudStack: &quot;<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>&quot;</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></div><footer class="row docusaurus-mt-lg blogPostFooterDetailsFull_mRVl"><div class="col margin-top--sm"><a href="https://github.com/apache/cloudstack-www/tree/main/blog/2013-03-18-apache_cloudstack_weekly_news_181.md" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_Z9Sw" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Blog post page navigation"><a class="pagination-nav__link pagination-nav__link--prev" href="/blog/the_apache_software_foundation_announces"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">The Apache Software Foundation Announces Apache CloudStack Has Become A Top-Level Project</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/apache_cloudstack_weekly_news_111"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">Apache CloudStack Weekly News - 11 March 2013</div></a></nav></main></div></div></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="margin-bottom--sm"><a href="https://cloudstack.apache.org/" rel="noopener noreferrer" class="footerLogoLink_BH7S"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></a></div><div class="footer__copyright">
            <div class="social">
                <a href="mailto:dev-subscribe@cloudstack.apache.org">
		  <img src="/img/mail_mini_icon.svg" alt="">
		</a>
                <a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-2aegc22z7-tPCxpptfcebTBtd59qcZSQ">
		  <img src="/img/slack_mini_icon.svg" alt="">
		</a>
                <a href="https://github.com/apache/cloudstack">
		  <img src="/img/git_mini_icon.svg" alt="">
		</a>
                <a href="https://twitter.com/CloudStack">
		  <img src="/img/twitter_X_mini_icon.svg" alt="">
		</a>
                <a href="https://www.youtube.com/@ApacheCloudStack">
		  <img src="/img/youtube_mini_icon.svg" alt="">
		</a>
                <a href="https://www.linkedin.com/company/apachecloudstack/posts/">
		  <img src="/img/linkedin_icon.svg" alt="">
		</a>
            </div>
            <div class="footer-bottom">Copyright © 2023 The Apache
Software Foundation, Licensed under the Apache License, Version 2.0.
“Apache”, “CloudStack”, “Apache CloudStack”, the Apache CloudStack logo,
 the Apache CloudStack Cloud Monkey logo and the Apache feather logos
are registered trademarks or trademarks of The Apache Software
Foundation.
            <p class="footer-blue"><a href="/trademark-guidelines">Apache CloudStack Trademark Usage</a> - <a href="/bylaws">Apache CloudStack Community ByLaws</a> - <a href="https://github.com/apache/cloudstack-www">Website Source Code</a></p></div>
            </div>
          <br>
          </div></div></footer></div>
<script src="/assets/js/runtime~main.d78c67af.js"></script>
<script src="/assets/js/main.8e0276ef.js"></script>
</body>
</html>