<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    

    <meta name="author" content="The Apache Software Foundation">

    
      <meta name="keywords" content="python,libcloud,cloud,cloud computing,rackspace,amazon ec2,cloudfiles,openstack,cloudstack" />
    

    
      <title>Apache Libcloud | Apache Libcloud</title>
    

    <!-- fav icons -->
    <link rel="shortcut icon" href="/images/favicon.png" />
    <link rel="apple-touch-icon" href="/images/apple-touch-icon.png" />
    <link rel="apple-touch-icon-precomposed" href="/images/apple-touch-icon.png" />

    <link href="/blog/atom.xml" type="application/atom+xml" rel="alternate" title="Apache Libcloud Blog Feed" />

    <!-- Facebook OpenGraph tags -->
    <meta content="Apache Libcloud" property="og:site_name">
    
      <meta content="Apache Libcloud" property="og:title">
    

    

    

    
      <meta content="website" property="og:type">
    

    
      <meta content="https://libcloud.apache.org/blog/tags/infrastructure" property="og:url">
    
    

    

    <link href='/assets/global-0faf439f2f098e60d3f1e591316155fc.css' rel='stylesheet' type='text/css' />
  </head>

  <body data-spy="scroll" data-target=".sidebar-nav" data-offset="80">
    <nav class="navbar navbar-fixed-top navbar-inverse" role="navigation">
      <div class="container">
        <div class="navbar-header">
          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-ex1-collapse">
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
          </button>
          <a class="navbar-brand" href="/"><img src="/images/libcloud_logo.png" class="navbar-logo" /> Apache Libcloud</a>
        </div>
        <div class="collapse navbar-collapse navbar-ex1-collapse">
          <ul class="nav navbar-nav">
            
            
              
              <li ><a href="/" >Home</a></li>
            
              
              <li ><a href="/about.html" >About</a></li>
            
              
              <li ><a href="/getting-started.html" >Quick Start</a></li>
            
              
              <li ><a href="https://libcloud.readthedocs.org/en/stable/" target="_blank">Documentation</a></li>
            
              
              <li ><a href="/downloads.html" >Downloads</a></li>
            
              
              <li ><a href="/community.html" >Community</a></li>
            
              
              <li ><a href="/blog/" >Blog</a></li>
            
          </ul>

          <div class="material-switch pull-right">
              <input id="theme-switch" name="theme-switch" type="checkbox" onclick="modeSwitcher()"/>
              <label for="theme-switch" class="label-default"></label>
              <span id="theme-toggle" class="theme-switch">Dark mode</span>
          </div>

        </div><!-- /.navbar-collapse -->
      </div><!-- /.container -->
    </nav>

    <div class="container main-container">
      <div class="row section page-content">
  <div class="col-lg-8 col-lg-offset-2">
    <h1>Tag: infrastructure</h1>



  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2022/03/30/website-updates.html">Website Updates</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Mar 30, 2022</span>

  <div class="post-content">
    <p>Today we are happy to announce various website updates. Here is a short
summary of those updates.</p>

<ul>
  <li>Move from svn to git for storing the website source code and the
generated static content (<a href="https://github.com/apache/libcloud-site">https://github.com/apache/libcloud-site</a>)</li>
  <li>New Docker image to make it easier to build and contribute to the website</li>
  <li>Upgrades to the various software and libraries used to build and serve
the website (Jekyll, Ruby, Ruby Gems, jQuery, Bootstrap, etc.).</li>
  <li>Dark mode / theme for the website</li>
  <li>Removal of Google tracking code (Google Analytics, Google Fonts)</li>
  <li>Removal of various Ruby gems which are not needed to build the website</li>
  <li>Other minor styling improvements</li>
</ul>

<div class="imginline">
  <p><img src="/images/posts/tbd/dark_theme.png" class="img-responsive inline" /></p>
  <p class="img-caption">Website using dark mode.</p>
</div>

<p>More on that below.</p>

<h2 id="background-context">Background, Context</h2>

<p>It has been over 8 years since the new static <a href="https://libcloud.apache.org/blog/2014/01/23/welcome-to-the-new-website.html">Jekyll powered website has
been launched</a>.</p>

<p>8 years is a long time and since then a lot has changed. Especially in the web
world, but the website stayed more or less the same.</p>

<p>Since the website is purely static and doesn’t contain any dynamic server side
components this means that not updating the software which is used to build the
website has no negative security implications for the end users (that’s a nice
thing about all the static website generators). This is vastly different if you
run a server side CMS such as Wordpress or similar where you need to make sure
it’s always up to date with the latest security patches.</p>

<p>Main problem with using old software (Ruby, Jekyll) was that it was very hard
to reproduce local development environment which made it almost impossible for
others to contribute - even I had issues with reproducing the environment in
the past year.</p>

<p>We used Ruby 1.9 and Jekyll 1.5 which were both almost 8 years old and
officially deprecated and non-supported for many years already.</p>

<p>At first, I only wanted to create a Docker image with this old software which
would make it easier for other people to contribute and build the website
locally.</p>

<p>It turned out that even that is very hard now because of the various old
versions of the software and libraries that software depends on. After
many hours, I did <a href="https://libcloud.apache.org/blog/2014/01/23/welcome-to-the-new-website.html">get it to work</a>, but I decide to try to go a step
further and see if I can actually update Ruby and Jekyll.</p>

<p>And surely, it turned out that’s not an easy task either. Over the years,
Jekyll had many releases with breaking changes and to make things worse, we
also utilize some custom Jekyll plugins which needed to be updated (I was
actually already somewhat aware I’m opening a can of worms because I
already tried to do that a couple of times in the past, but each time I
decided to abandon those efforts since it required too much work / time).</p>

<p>In the end, after addressing all of those various issues and breaking changes,
I got everything to work.</p>

<p>To make contributing even easier and faster, we also provide a pre-built Docker
image with the development environment which should save some time and CPU
cycles since the image doesn’t need to be built locally (sadly the image is on
the larger side because a lot of tooling is needed to build the website - I do
hope to reduce that a bit in a future when I get a chance by using a multi
stage build).</p>

<p>Since I was already working on the website I also decided to make a bunch of
other changes, my favorite one being dark mode / theme. I personally already
use <a href="https://addons.mozilla.org/sl/firefox/addon/darkreader/">Dark Reader extension for Firefox</a> which automatically provides dark
mode for most websites on the fly, but I know now everyone is using something
like that and a native dark mode / theme is usually better.</p>

<p>The source code and everything else for the new website is available at
<a href="https://github.com/apache/libcloud-site">https://github.com/apache/libcloud-site</a>.</p>

<h2 id="conclusion">Conclusion</h2>

<p>We hope you will enjoy those new changes and most importantly, we hope
those changes will decrease the barrier to entry and make contributing to
the website easier and faster.</p>

<p>P.S. If you find any bugs or issues with those changes (especially the dark
theme), please feel free to report them or, if possible, contribute the fix
directly - that would be much appreciated.</p>


  </div>

  <div class="row section post-meta">
    <div class="col-md-12 post-tags">
      <p>Tags: <a href="/blog/tags/news.html" rel="tag">news</a>, <a href="/blog/tags/infrastructure.html" rel="tag">infrastructure</a>, <a href="/blog/tags/website.html" rel="tag">website</a>, <a href="/blog/tags/git.html" rel="tag">git</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/01/23/welcome-to-the-new-website.html">Welcome to the new website</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 23, 2014</span>

  <div class="post-content">
    <p>Today we are pleased to announce a new, improved and more user friendly version
of our website.</p>

<h3 id="background-and-history">Background and History</h3>

<p>Original website was developed and published back in 2009 when the project was
first announced.</p>

<p>A lot has changed since 2009 and during that time the web has been evolving at
a rapid pace. Now we have terms such as <a href="http://getbootstrap.com/">responsive web design</a>, great
front-end frameworks for building responsive websites such as <a href="http://getbootstrap.com/">Bootstrap</a>
and <a href="http://foundation.zurb.com/">Zurb</a> and many other new things which didn’t exist or weren’t widely
used back when we first launched.</p>

<p>During this time we focused most of our efforts on improving the code and
making the library better. This meant the website didn’t receive a lot of
needed love and attention so design-wise, it was mostly stuck in the 2009 era.</p>

<p>Over the years it has become apparent that presentation and documentation is
also equally or even more important then the code itself, so we have decided
to fix some of the “mistakes” we have made in the past.</p>

<p>A couple of months back we launched a <a href="https://libcloud.readthedocs.org/en/latest/">new documentation</a> and today, we are
happy to present you a new and much improved website which was built with
modern tools and principles in mind.</p>

<h3 id="improvements-and-new-features">Improvements and New Features</h3>

<div class="imginline">
  <p><img src="/images/posts/tbd/preview.png" class="img-responsive inline" /></p>
  <p class="img-caption">Responsive design makes a site pleasure to use on a
  variety of devices and screen sizes. Image by placeit.net.</p>
</div>

<p>New website includes many improvements and new features. Some of the more
important ones are listed bellow.</p>

<h4 id="more-modern-and-user-friendly-design">More modern and user-friendly design</h4>

<p>New website now features a more modern and user-friendly design. This includes
bigger fonts, better typography and so on.</p>

<p>On top of that, the new design is fully responsive which means you can now
better enjoy the content on smaller devices such as mobile phones and tablets.</p>

<h4 id="improved-and-re-designed-landing-page">Improved and re-designed landing page</h4>

<p>We know that landing pages are very important so we have decided to totally
re-design and re-organise ours.</p>

<p>New landing page now displays all the important information (project features,
code examples, showcases some companies and projects using Libcloud) and also
features a more clear call to action.</p>

<h4 id="blog-section">Blog section</h4>

<p>New website now features a fully-fledged blog.</p>

<p>We will use the blog to post important project news, keep you up to date with
what is currently going on and post case studies and stories from projects and
companies which are using Libcloud.</p>

<p>If you are using an RSS reader to stay up to date, we also offer an
<a href="/blog/atom.xml">ATOM feed</a>.</p>

<h4 id="updated-credits-page">Updated Credits Page</h4>

<p><a href="/credits.html">Credits</a> page now features an up to date list of people who have
contributed code and documentation.</p>

<p>As noted on that page, the list is automatically generated from the CHANGES
file so it might not be 100% accurate.</p>

<h4 id="search-engine-optimizations">Search Engine Optimizations</h4>

<p>We have made some changes which will make our website a bit more friendly to
the web crawlers and search engines. We hope this will make it easier for you
to more quickly find the content you are looking for.</p>

<p>The changes we have made include improvements to the underlying HTML markup,
addition of the <a href="http://ogp.me/">OpenGraph</a> tags and an addition of a sitemap.</p>

<h3 id="under-the-hood">Under the Hood</h3>

<p>Old website was powered by <a href="http://www.apache.org/dev/cms.html">Apache CMS</a>. It mostly worked good enough for
simple use cases, but a small user base means it lacks a large ecosystem around
it which is pretty standard for many other popular content management systems.</p>

<p>Because of that, we have decided to switch to <a href="http://jekyllrb.com/">Jekyll</a>, a Ruby based static
website and blog engine.</p>

<p>On top of that, the new website is fully responsive and built using
<a href="http://getbootstrap.com/">Bootstrap 3</a> front-end framework.</p>

<p>Similar to the old website, source code is still stored in an SVN repository
so all the benefits we get from version control are preserved.</p>

<p>Source code of the new website can be found in the <a href="https://svn.apache.org/repos/asf/libcloud/site/trunk/">SVN repository</a>.</p>

<h3 id="conclusion">Conclusion</h3>

<p>We hope you will like and enjoy the new website.</p>

<p>We also hope the new website now better reflects the underlying evolution of
the library and the direction we are heading.</p>

<p>If you have any suggestions on how we can make the website even better, don’t
hesitate and share it with us. You can send your feedback to the
<a href="/community.html#mailing-lists">mailing list</a>, or you can <a href="/community.html#website-repository">checkout the website repository</a> and make
the changes yourself.</p>


  </div>

  <div class="row section post-meta">
    <div class="col-md-12 post-tags">
      <p>Tags: <a href="/blog/tags/news.html" rel="tag">news</a>, <a href="/blog/tags/infrastructure.html" rel="tag">infrastructure</a>, <a href="/blog/tags/website.html" rel="tag">website</a>, <a href="/blog/tags/git.html" rel="tag">git</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/05/05/website-and-code-svn-repository-moved.html">SVN repositories moved, mailing lists addresses changed</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on May 05, 2012</span>

  <div class="post-content">
    <p>Hello all,</p>

<p>Due to recent graduation (woho!), all the SVN repositories have been moved
and the mailing list addresses have also been changed.</p>

<p>If you are already subscribed to one of the old mailing list addresses your
subscription was automatically transfered to the new one so you don’t need
to do anything on your part.</p>

<p>New addresses can be found bellow.</p>

<p><strong>SVN repositories</strong></p>

<ul>
  <li>Main code repository: https://svn.apache.org/repos/asf/libcloud/</li>
  <li>Website repository:
https://svn.apache.org/repos/infra/websites/production/libcloud</li>
</ul>

<p><strong>Mailing lists addresses</strong></p>

<ul>
  <li>dev@libcloud.apache.org (was libcloud@incubator.apache.org)</li>
  <li>commits@libcloud.apache.org from (was
libcloud-commits@incubator.apache.org)</li>
  <li>
    <p>private@libcloud.apache.org from (was
libcloud-private@incubator.apache.org)</p>
  </li>
  <li>users@libcloud.apache.org - this is a new users mailing list for a general
talk about Libcloud and other off-topic things</li>
  <li>security@libcloud.apache.org - new private mailing list used for reporting
security vulnerabilities</li>
</ul>

<h2 id="note-to-the-committers">Note to the committers</h2>

<p>CMS part of the website hasn’t been fully migrated yet. In the mean time,
please try to avoid editing raw HTML files, because this means we will need
to manually edit markdown files again when the CMS stuff is migrated.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201105.mbox/%3CBANLkTinTq7RrKpe8SMmSeKKW8yQpu-77Ew@mail.gmail.com%3E">mailing list thread</a>.</p>


  </div>

  <div class="row section post-meta">
    <div class="col-md-12 post-tags">
      <p>Tags: <a href="/blog/tags/news.html" rel="tag">news</a>, <a href="/blog/tags/infrastructure.html" rel="tag">infrastructure</a>, <a href="/blog/tags/svn.html" rel="tag">svn</a>, <a href="/blog/tags/website.html" rel="tag">website</a></p>
    </div>
  </div>
</div>

  


  </div>
</div>


      <hr />

      <footer>
        <div class="row">
          <div class="col-lg-12 text-center">
            <div class="footer-links">
  <p><a href="http://www.apache.org/licenses/">License</a> | <a
  href="/security.html">Security</a> | <a
  href="http://www.apache.org/foundation/sponsorship.html">Sponsorship</a> |
  <a href="http://www.apache.org/foundation/thanks.html">Thanks</a> |
  <a href="https://www.apache.org/events/">Events</a> |
  <a href="/credits.html">Credits</a> | <a href="/media.html">Media</a>
</div>

<div class="footer-text">
  <p><a class="acevent" data-format="wide"></a></p>
  <p class="">Copyright &copy; 2009-2023 <a href="https://www.apache.org/" target="_blank">The Apache Software Foundation</a></p>
  <p class="">Apache Libcloud, Libcloud, Apache, the Apache feather, and the Apache Libcloud project logo are trademarks of the Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.</p>
  <p class="">Site last updated on 2023-09-09 21:30:54 +0000</p>
</div>

          </div>
        </div>
      </footer>

    </div><!-- /.container -->

    <!-- JavaScript -->
    <script src='/assets/global-dac9eed9206cf02359a2dd1d7c03e401.js' type='text/javascript'></script>

    

    <script type="text/javascript">
  var _paq = window._paq = window._paq || [];
  /* tracker methods like "setCustomDimension" should be called before
"trackPageView" */
  /* We explicitly disable cookie tracking to avoid privacy issues */
  _paq.push(['disableCookies']);
  _paq.push(['trackPageView']);
  _paq.push(['enableLinkTracking']);
  (function() {
    var u="https://analytics.apache.org/";
    _paq.push(['setTrackerUrl', u+'matomo.php']);
    _paq.push(['setSiteId', '7']);
    var d=document, g=d.createElement('script'),
s=d.getElementsByTagName('script')[0];
    g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
  })();
</script>

    <script src="https://www.apachecon.com/event-images/snippet.js"></script>

  </body>
</html>
