<!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">The Apache Software Foundation Announces Apache® CloudStack® v4.15 | 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/the-apache-software-foundation-announces2"><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="The Apache Software Foundation Announces Apache® CloudStack® v4.15 | Apache CloudStack"><meta data-rh="true" name="description" content="The Apache CloudStack Project Releases Apache® CloudStack® v4.15"><meta data-rh="true" property="og:description" content="The Apache CloudStack Project Releases Apache® CloudStack® v4.15"><meta data-rh="true" property="og:type" content="article"><meta data-rh="true" property="article:published_time" content="2021-01-19T00:00:00.000Z"><meta data-rh="true" property="article:author" content="https://github.com/rohityadavcloud"><meta data-rh="true" property="article:tag" content="announcement"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://cloudstack.apache.org/blog/the-apache-software-foundation-announces2"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/the-apache-software-foundation-announces2" hreflang="en"><link data-rh="true" rel="alternate" href="https://cloudstack.apache.org/blog/the-apache-software-foundation-announces2" hreflang="x-default"><link rel="alternate" type="application/rss+xml" href="/blog/rss.xml" title="Apache CloudStack RSS Feed">
<link rel="alternate" type="application/atom+xml" href="/blog/atom.xml" title="Apache CloudStack Atom Feed">






<script src="scripts/bootstrap.bundle.min.js" async></script><link rel="stylesheet" href="/assets/css/styles.e12efb83.css">
<link rel="preload" href="/assets/js/runtime~main.60ecdf28.js" as="script">
<link rel="preload" href="/assets/js/main.2d60fa8d.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/navlogo.png" alt="apache-cloudstack" class="themedImage_ToTc themedImage--dark_i4oU"></div><b class="navbar__title text--truncate"></b></a></div><div class="navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">About</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/about">About</a></li><li><a class="dropdown__link" href="/history">History</a></li><li><a class="dropdown__link" href="/features">Features</a></li><li><a class="dropdown__link" href="/who">Who We Are</a></li><li><a class="dropdown__link" href="/bylaws">Community Bylaws</a></li><li><a class="dropdown__link" href="/trademark-guidelines">Trademark Guidelines</a></li><li><a class="dropdown__link" href="/security">Security</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/contribute">Get Involved</a></li><li><a class="dropdown__link" href="/developers">Developer Resources</a></li><li><a class="dropdown__link" href="/mailing-lists">Join Mailing Lists</a></li><li><a href="https://github.com/apache/cloudstack/issues" target="_blank" rel="noopener noreferrer" class="dropdown__link">Issues Tracker<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-1u8qwbivp-u16HRI~LWioLmF1G2D3Iyg" target="_blank" rel="noopener noreferrer" class="dropdown__link">Community Slack<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/events">Events and Meetups</a></li><li><a href="https://www.cloudstackcollab.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Collab Conference<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Use Cases</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/cloud-builders">Cloud Builders</a></li><li><a class="dropdown__link" href="/kubernetes">Kubernetes</a></li><li><a class="dropdown__link" href="/integrations">Integrations</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Users</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/users">Known Users</a></li><li><a class="dropdown__link" href="/blog/blog/tags/case-studies">Case Studies</a></li><li><a href="https://docs.google.com/forms/d/e/1FAIpQLScPHIRetdt-pxPT62IesXMoQUmhQ8ATGKcYZa507mB9uwzn-Q/viewform" target="_blank" rel="noopener noreferrer" class="dropdown__link">Take Survey<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Documentation</a><ul class="dropdown__menu"><li><a href="https://docs.cloudstack.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Documentation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/Home" target="_blank" rel="noopener noreferrer" class="dropdown__link">Project Wiki<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://cwiki.apache.org/confluence/display/CLOUDSTACK/CloudStack+Books" target="_blank" rel="noopener noreferrer" class="dropdown__link">CloudStack Books<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a class="dropdown__link" href="/api/">API Documentation</a></li></ul></div><a class="navbar__item navbar__link" href="/downloads">Download</a><a class="navbar__item navbar__link" href="/blog">Blog</a><a href="https://github.com/apache/cloudstack" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link header-github-link" aria-label="GitHub repository"></a><div class="searchBox_ZlJk"><div class="navbar__search searchBarContainer_NW3z"><input placeholder="Search" aria-label="Search" class="navbar__search-input"><div class="loadingRing_RJI3 searchBarLoadingRing_YnHq"><div></div><div></div><div></div><div></div></div><div class="searchHintContainer_Pkmr"><kbd class="searchHint_iIMx">ctrl</kbd><kbd class="searchHint_iIMx">K</kbd></div></div></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">ASF</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation</a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License</a></li><li><a href="https://www.apache.org/events/current-event" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events</a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security</a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship</a></li><li><a href="https://www.apache.org/foundation/policies/privacy.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Privacy</a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks</a></li></ul></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><div class="container margin-vert--lg blog-container"><div class="row"><aside class="col col--3"><nav class="sidebar thin-scrollbar"><div class="sidebarItemTitle margin-bottom--md">CloudStack Blog</div><ul class="sidebarItemList clean-list"><li class="sidebarItem"><a class="sidebarItemLink" href="/blog">All Posts</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/news">News</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/announcement">Announcements</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/roundup">Past Events</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/case-studies">Case Studies &amp; Integrations</a></li><li class="sidebarItem"><a class="sidebarItemLink" href="/blog/tags/community">Meet the Community</a></li></ul></nav></aside><main class="col col--7" itemscope="" itemtype="http://schema.org/Blog"><article itemprop="blogPost" itemscope="" itemtype="http://schema.org/BlogPosting"><meta itemprop="description" content="The Apache CloudStack Project Releases Apache® CloudStack® v4.15"><header><h1 class="title_f1Hy" itemprop="headline">The Apache Software Foundation Announces Apache® CloudStack® v4.15</h1><div class="container_mt6G margin-vert--md"><time datetime="2021-01-19T00:00:00.000Z" itemprop="datePublished">January 19, 2021</time></div><div class="margin-top--md margin-bottom--sm row"><div class="col col--6 authorCol_Hf19"><div class="avatar margin-bottom--sm"><a href="https://github.com/rohityadavcloud" target="_blank" rel="noopener noreferrer" class="avatar__photo-link"><img class="avatar__photo" src="https://github.com/rohityadavcloud.png" alt="Rohit Yadav" itemprop="image"></a><div class="avatar__intro" itemprop="author" itemscope="" itemtype="https://schema.org/Person"><div class="avatar__name"><a href="https://github.com/rohityadavcloud" target="_blank" rel="noopener noreferrer" itemprop="url"><span itemprop="name">Rohit Yadav</span></a></div><small class="avatar__subtitle" itemprop="description">PMC Member</small></div></div></div></div></header><div id="__blog-post-container" class="markdown" itemprop="articleBody"><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&#x27;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 &quot;just works&quot;.</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>&quot;We are pleased to announce our latest release, making CloudStack even easier to deploy full-featured public and private clouds,&quot; said Sven Vogel, Vice President of Apache CloudStack. &quot;Apache CloudStack continues to grow from strength to strength, with upgraded software and powerful deployments, backed by a robust community.&quot;</p><p>Apache CloudStack v4.15
Apache CloudStack includes the entire &quot;stack&quot; 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 &quot;deploy-as-is&quot; 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>&quot;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,&quot; said Andre Walter, VP, Head of GMS Cloud Infrastructure Services at Itelligence Global Managed Services GmbH. &quot;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.&quot;</p><p>&quot;Apache CloudStack continues to bring innovative features for public cloud providers like us,&quot;  said Wido den Hollander, CTO of PCExtreme. &quot;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.&quot;</p><p>&quot;Apache CloudStack continues to cement itself as the logical choice for reliable, open source IaaS orchestration,&quot; said Giles Sirett, CEO of ShapeBlue. &quot;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.&quot;</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&#x27;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, &quot;sits beneath hundreds of service provider clouds&quot;. 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. &quot;Apache&quot;, &quot;CloudStack&quot;, &quot;Apache CloudStack&quot;, and &quot;ApacheCon&quot; 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></div><footer class="row docusaurus-mt-lg blogPostFooterDetailsFull_mRVl"><div class="col"><b>Tags:</b><ul class="tags_jXut padding--none margin-left--sm"><li class="tag_QGVx"><a class="tag_zVej tagRegular_sFm0" href="/blog/tags/announcement">announcement</a></li></ul></div><div class="col margin-top--sm"><a href="https://github.com/apache/cloudstack-www/tree/main/blog/2021-01-19-the-apache-software-foundation-announces2.md" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_Z9Sw" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Blog post page navigation"><a class="pagination-nav__link pagination-nav__link--prev" href="/blog/apache-cloudstack-lts-maintenance-release"><div class="pagination-nav__sublabel">Newer Post</div><div class="pagination-nav__label">Apache CloudStack LTS Maintenance Release 4.14.1.0</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/blog/the-apache-software-foundation-announces1"><div class="pagination-nav__sublabel">Older Post</div><div class="pagination-nav__label">The Apache Software Foundation Announces Apache® CloudStack® v4.14</div></a></nav></main></div></div></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="margin-bottom--sm"><a href="https://cloudstack.apache.org/" rel="noopener noreferrer" class="footerLogoLink_BH7S"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/ACS_logo_slogan.svg" alt="Apache CloudStack logo" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></a></div><div class="footer__copyright">
            <div class="social">
                <a href="mailto:dev-subscribe@cloudstack.apache.org">
		  <img src="/img/mail_mini_icon.svg" alt="">
		</a>
                <a href="https://join.slack.com/t/apachecloudstack/shared_invite/zt-2aegc22z7-tPCxpptfcebTBtd59qcZSQ">
		  <img src="/img/slack_mini_icon.svg" alt="">
		</a>
                <a href="https://github.com/apache/cloudstack">
		  <img src="/img/git_mini_icon.svg" alt="">
		</a>
                <a href="https://twitter.com/CloudStack">
		  <img src="/img/twitter_X_mini_icon.svg" alt="">
		</a>
                <a href="https://www.youtube.com/@ApacheCloudStack">
		  <img src="/img/youtube_mini_icon.svg" alt="">
		</a>
                <a href="https://www.linkedin.com/company/apachecloudstack/posts/">
		  <img src="/img/linkedin_icon.svg" alt="">
		</a>
            </div>
            <div class="footer-bottom">Copyright © 2023 The Apache
Software Foundation, Licensed under the Apache License, Version 2.0.
“Apache”, “CloudStack”, “Apache CloudStack”, the Apache CloudStack logo,
 the Apache CloudStack Cloud Monkey logo and the Apache feather logos
are registered trademarks or trademarks of The Apache Software
Foundation.
            <p class="footer-blue"><a href="/trademark-guidelines">Apache CloudStack Trademark Usage</a> - <a href="/bylaws">Apache CloudStack Community ByLaws</a> - <a href="https://github.com/apache/cloudstack-www">Website Source Code</a></p></div>
            </div>
          <br>
          </div></div></footer></div>
<script src="/assets/js/runtime~main.60ecdf28.js"></script>
<script src="/assets/js/main.2d60fa8d.js"></script>
</body>
</html>