<!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/news" 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: news</h1>



  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2023/08/10/libcloud-3-8-0-released.html">Libcloud 3.8.0 Released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Aug 10, 2023</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.8.0.</p>

<p>This release includes new features, improvements, and bug fixes.</p>

<p>Highlights include:</p>

<ul>
  <li>Performance improvements in the storage drivers</li>
  <li>Removal of 18 drivers for providers that are no longer active (they went
out of business, have been acquired, or similar).</li>
</ul>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.8.0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.8.0</a>.</p>

<h3 id="development-related-changes-developers-only">Development-Related Changes (developers only)</h3>

<p>In addition to the end-user visible changes, we have made various changes to our
development process and practices to better follow and align with modern
Python development and packaging best practices.</p>

<ul>
  <li>Tooling (pylint, mypy, bandit, isort, black, etc.) config options have been
migrated into pyproject.yaml file.</li>
  <li>Package setup and build-related metadata have been migrated from setup.py
and setup.cfg to pyproject.toml.</li>
  <li>The unsafe “setup.py test” wrapper command has been removed in favor of
invoking pytest directly.</li>
  <li>The “build” PyPi package is now used for creating release artifacts (sdist, wheel)
in an isolated virtual environment.</li>
</ul>

<h3 id="download">Download</h3>

<p>The release can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.8.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip, you can also use it to upgrade:</p>

<pre>
pip install --upgrade "apache-libcloud==3.8.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page that describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.8.0/">https://libcloud.readthedocs.org/en/v3.8.0/</a></p>

<h3 id="bugsissues">Bugs/Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and/or test that reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! The full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.8.0/changelog.html">CHANGES file</a>.</p>

<p>Special thanks to Anthony Monthe - @ZuluPro for contributing driver removal /
clean up change.</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2023/01/08/libcloud-3-7-0-released.html">Libcloud 3.7.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 08, 2023</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.7.0.</p>

<p>This release includes new features, improvements and bug fixes.</p>

<p>Highlights include:</p>

<ul>
  <li>Improvements in the CloudSigma compute driver</li>
  <li>Support for <code class="language-plaintext highlighter-rouge">af-south-1</code> region in the Amazon S3 storage driver</li>
  <li>Bug fix for OAuth2 desktop client authentication in the Google Cloud
Platform compute driver</li>
  <li>Support for Python 3.6 has been dropped</li>
</ul>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.7.0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.7.0</a>.</p>

<h3 id="note-on-python-36-support">Note on Python 3.6 support</h3>

<p>Python 3.6 support has been dropped in Libcloud v3.7.0.</p>

<p>Python 3.6 has been EOL and non-supported for more than a year now
(<a href="https://endoflife.date/python">https://endoflife.date/python</a>) and a lot of libraries (including some we
depend on) have already dropped support for it.</p>

<p>Last release which still supports Python 3.6 is Libcloud v3.6.1.</p>

<h3 id="note-on-code-style-change-developers-only">Note on code style change (developers only)</h3>

<p>To make formatting and styling in our code base more consistent, we have
re-formatted all the code with black (<a href="https://github.com/psf/black">https://github.com/psf/black</a>) and
pyupgrade Python 3.5+ (<a href="https://github.com/asottile/pyupgrade">https://github.com/asottile/pyupgrade</a>) and we will
automatically enforce black code style (<a href="https://black.readthedocs.io/en/stable/">https://black.readthedocs.io/en/stable/</a>)
and pyupgrade checks for all the new code going forward.</p>

<p>This should make it easier to contribute and read the code since all the code
will be using the same style.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.7.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.7.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.7.0/">https://libcloud.readthedocs.org/en/v3.7.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.7.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2022/10/10/libcloud-3-6-1-released.html">Libcloud 3.6.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Oct 10, 2022</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.6.1.</p>

<p>This release includes new features, improvements and bug fixes.</p>

<p>Highlights include:</p>

<ul>
  <li>Improvements in the EC2 price scraping script and updated pricing</li>
  <li>Improvements in the Azure ARM compute driver</li>
  <li>Improvements in the GCE compute driver</li>
  <li>Various bug fixes in the EC2 compute, OpenStack compute, Azure storage and
other drivers</li>
</ul>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.6.1">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.6.1</a>.</p>

<h3 id="note-on-python-35-support">Note on Python 3.5 support</h3>

<p>Python 3.5 support has been dropped in Libcloud v3.5.0.</p>

<p>Python 3.5 has been EOL and non-supported for more than a year now
(<a href="https://endoflife.date/python">https://endoflife.date/python</a>) and a lot of libraries (including some we
depend on) have already dropped support for it.</p>

<p>Last release which still supports Python 3.5 is Libcloud v3.4.1.</p>

<h3 id="note-on-code-style-change-developers-only">Note on code style change (developers only)</h3>

<p>To make formatting and styling in our code base more consistent, we have
re-formatted all the code with black (<a href="https://github.com/psf/black">https://github.com/psf/black</a>) and
pyupgrade Python 3.5+ (<a href="https://github.com/asottile/pyupgrade">https://github.com/asottile/pyupgrade</a>) and we will
automatically enforce black code style (<a href="https://black.readthedocs.io/en/stable/">https://black.readthedocs.io/en/stable/</a>)
and pyupgrade checks for all the new code going forward.</p>

<p>This should make it easier to contribute and read the code since all the code
will be using the same style.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.6.1"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.6.1"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.6.1/">https://libcloud.readthedocs.org/en/v3.6.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.6.1/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2022/05/26/libcloud-3-6-0-released.html">Libcloud 3.6.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on May 26, 2022</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.6.0.</p>

<p>This release includes new features, improvements and bug fixes.</p>

<p>Highlights include:</p>

<ul>
  <li>Improvements in the Kuberneter container driver</li>
  <li>Improvements in the OpenStack compute driver (support for micro versions,
etc.)</li>
  <li>Compatibility / support for paramiko &gt;= 2.9.0 including backward
compatibility layer for backward incompatible changes in paramiko related
to old OpenSSH versions. More information on that available in the Upgrade
Notes -
<a href="https://libcloud.readthedocs.io/en/latest/upgrade_notes.html#libcloud-3-6-0">https://libcloud.readthedocs.io/en/latest/upgrade_notes.html#libcloud-3-6-0</a></li>
  <li>Support for authenticating using Azure AD credentials in the Azure Blobs
storage driver</li>
</ul>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.6.0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.6.0</a>.</p>

<h3 id="note-on-python-35-support">Note on Python 3.5 support</h3>

<p>Python 3.5 support has been dropped in Libcloud v3.5.0.</p>

<p>Python 3.5 has been EOL and non-supported for more than a year now
(<a href="https://endoflife.date/python">https://endoflife.date/python</a>) and a lot of libraries (including some we
depend on) have already dropped support for it.</p>

<p>Last release which still supports Python 3.5 is Libcloud v3.4.1.</p>

<h3 id="note-on-code-style-change-developers-only">Note on code style change (developers only)</h3>

<p>To make formating and styling in our code base more consistent, we have
re-formatted all the code with black (<a href="https://github.com/psf/black">https://github.com/psf/black</a>) and we will
automatically enforce black code style (<a href="https://black.readthedocs.io/en/stable/">https://black.readthedocs.io/en/stable/</a>)
for all the new code going forward.</p>

<p>This should make it easier to contribute and read the code since all the code
will be using the same style.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.6.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.6.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.6.0/">https://libcloud.readthedocs.org/en/v3.6.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.6.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <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/2022/03/30/libcloud-3-5-1-released.html">Libcloud 3.5.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Mar 30, 2022</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.5.1.</p>

<p>This release includes a small bug / fix improvement which allows HTTP retrying
code to also retry failed “raw” requests. In addition to that, it also
includes improvement in the GCE compute driver to retrieve some resources
lazily on demand instead of inside the driver constructor.</p>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.5.1">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.5.1</a>.</p>

<h3 id="note-on-python-35-support">Note on Python 3.5 support</h3>

<p>Libcloud v3.5.0 dropped support for Python 3.5.</p>

<p>Python 3.5 has been EOL and non-supported for more than a year
(<a href="https://endoflife.date/python">https://endoflife.date/python</a>) now and a lot of libraries (including some we
depend on) have already dropped support for it.</p>

<p>Last release which still supports Python 3.5 is Libcloud v3.4.1.</p>

<h3 id="note-on-code-style-change-developers-only">Note on code style change (developers only)</h3>

<p>To make formating and styling in our code base more consistent, we have
re-formatted all the code with black (<a href="https://github.com/psf/black">https://github.com/psf/black</a>) and we will
automatically enforce black code style (<a href="https://black.readthedocs.io/en/stable/">https://black.readthedocs.io/en/stable/</a>)
for all the new code going forward.</p>

<p>This should make it easier to contribute and read the code since all the code
will be using the same style.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.5.1"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.5.1"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.5.1/">https://libcloud.readthedocs.org/en/v3.5.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.5.1/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2022/03/12/libcloud-3-5-0-released.html">Libcloud 3.5.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Mar 12, 2022</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.5.0.</p>

<p>This release includes new features, improvements and bug fixes.</p>

<p>Highlights include:</p>

<ul>
  <li>Improvements to the OpenStack driver</li>
  <li>New storage driver for Scaleway Object Storage</li>
  <li>Improvements to the HTTP requests retrying code</li>
</ul>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.5.0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.5.0</a>.</p>

<h3 id="note-on-python-35-support">Note on Python 3.5 support</h3>

<p>This release drops support for Python 3.5.</p>

<p>Python 3.5 has been EOL and non-supported for more than a year
(<a href="https://endoflife.date/python">https://endoflife.date/python</a>) now and a lot of libraries (including some we
depend on) have already dropped support for it.</p>

<p>Last release which still supports Python 3.5 is Libcloud v3.4.1.</p>

<h3 id="note-on-code-style-change-developers-only">Note on code style change (developers only)</h3>

<p>To make formating and styling in our code base more consistent, we have
re-formatted all the code with black (<a href="https://github.com/psf/black">https://github.com/psf/black</a>) and we will
automatically enforce black code style (<a href="https://black.readthedocs.io/en/stable/">https://black.readthedocs.io/en/stable/</a>)
for all the new code going forward.</p>

<p>This should make it easier to contribute and read the code since all the code
will be using the same style.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.5.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.5.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.5.0/">https://libcloud.readthedocs.org/en/v3.5.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.5.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2021/11/15/libcloud-3-4-1-released.html">Libcloud 3.4.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 15, 2021</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.4.1.</p>

<p>This is a bug fix release which fixes an installation bug that was inadvertently
introduced in v3.4.0.</p>

<p>That bug broke installation under Python 3.5 and it also prevented Libcloud
from being installed inside the same (virtual) environment where older version
of the requests library was already installed or where some other dependency
depends on older version of the requests library.</p>

<h3 id="note-on-python-35-support">Note on Python 3.5 support</h3>

<p>Libcloud v3.4.x will be the last release series which still supports Python
3.5.</p>

<p>Python 3.5 has been EOL and non-supported for more than a year
(<a href="https://endoflife.date/python">https://endoflife.date/python</a>) now and a lot of libraries (including some we
depend on) have already dropped support for it.</p>

<p>This is making it increasingly hard for us to still support Python 3.5 since
it requires a bunch of edge cases in workarounds in our code and build system.</p>

<h3 id="note-on-code-style-change-developers-only">Note on code style change (developers only)</h3>

<p>To make formating and styling in our code base more consistent, we have
re-formatted all the code with black (<a href="https://github.com/psf/black">https://github.com/psf/black</a>) and we will
automatically enforce black code style (<a href="https://black.readthedocs.io/en/stable/">https://black.readthedocs.io/en/stable/</a>)
for all the new code going forward.</p>

<p>This should make it easier to contribute and read the code since all the code
will be using the same style.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.4.1"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.4.1"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.4.1/">https://libcloud.readthedocs.org/en/v3.4.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.4.1/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2021/11/11/libcloud-3-4-0-released.html">Libcloud 3.4.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 11, 2021</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.4.0.</p>

<p>This release includes new features, improvements and bug fixes.</p>

<p>Highlights include:</p>

<ul>
  <li>Improvements and more flexibility in the failed HTTP requests retrying code</li>
  <li>Various improvements to the Equinix Metal compute driver</li>
  <li>Improvements and updates to the Outscale, Vultr, CloudSigma and OpenStack
compute drivers</li>
  <li>Support for authenticating via API tokens to the CloudFlare DNS driver</li>
  <li>Support for using external cache for OpenStack auth tokens</li>
</ul>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.4.0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.4.0</a>.</p>

<h3 id="note-on-python-35-support">Note on Python 3.5 support</h3>

<p>Libcloud v3.4.x will be the last release series which still supports Python
3.5.</p>

<p>Python 3.5 has been EOL and non-supported for more than a year
(<a href="https://endoflife.date/python">https://endoflife.date/python</a>) now and a lot of libraries (including some we
depend on) have already dropped support for it.</p>

<p>This is making it increasingly hard for us to still support Python 3.5 since
it requires a bunch of edge cases in workarounds in our code and build system.</p>

<h3 id="note-on-code-style-change-developers-only">Note on code style change (developers only)</h3>

<p>To make formating and styling in our code base more consistent, we have
re-formatted all the code with black (<a href="https://github.com/psf/black">https://github.com/psf/black</a>) and we will
automatically enforce black code style (<a href="https://black.readthedocs.io/en/stable/">https://black.readthedocs.io/en/stable/</a>)
for all the new code going forward.</p>

<p>This should make it easier to contribute and read the code since all the code
will be using the same style.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.4.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.4.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.4.0/">https://libcloud.readthedocs.org/en/v3.4.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.4.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2021/06/03/dimitris-moraitis-joins-our-team.html">Dimitris Moraitis (dmo) joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jun 03, 2021</span>

  <div class="post-content">
    <p>Please help us extend a warm welcome to our newest team member <a href="https://github.com/d-mo">Dimitris Moraitis</a>!</p>

<p>The Project Management Committee (PMC) for Apache Libcloud has invited Dimitris
Moraitis to join us as a committer and we are pleased to announce that
they have accepted.</p>

<p>Dimitris is one of the founders and main contributors to the open source multi
cloud management project called <a href="https://github.com/mistio/mist-ce">Mist.io</a>.</p>

<p>Mist.io has been an early user and adopter of Libcloud. Over the years,
Dimitris and the rest of the Mist.io team have contributed many changes and
improvements to Libcloud.</p>

<p>For anyone who would like to know more about Dimitris here is his short bio:</p>

<blockquote>
  <p>Dimitris is an entrepreneur &amp; engineer committed to open technologies. He
holds a UoA CS BSc. He has been serving as the technical lead for organizations
around the world since 2001. He’s the co-founder &amp; CTO of Mist.io, the open
source multicloud management platform. He’s particularly interested in DevOps,
UX, AI/ML and the social impact of technology.</p>
</blockquote>


  </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/new-committer.html" rel="tag">new committer</a>, <a href="/blog/tags/new-pmc-member.html" rel="tag">new pmc member</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2021/01/25/libcloud-3-3-1-released.html">Libcloud 3.3.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 25, 2021</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.3.1.</p>

<p>This release includes 2 bug fixes.</p>

<p>One of them fixes a regression in EC2 driver which was inadvertently
introduced in v3.3.1. That regression broke authentication for some
regions such as us-east-2 which utilize authentication algorithm
version 4.</p>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.3.1">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.3.1</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.3.1"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.3.1"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.3.1/">https://libcloud.readthedocs.org/en/v3.3.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to <a href="https://github.com/olegrtecno">@olegrtecno</a> for reporting EC2 authentication issue and
<a href="https://github.com/RunOrVeith">Veith Röthlingshöfer - @RunOrVeith</a> for reporting bug in Google Storage
driver which has also been fixed in this release.</p>

<p>Full list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.3.1/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2021/01/02/libcloud-3-3-0-released.html">Libcloud 3.3.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 02, 2021</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.3.0.</p>

<p>This release includes various improvements and bug fixes.</p>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-3-0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-3-0</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.3.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.3.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.3.0/">https://libcloud.readthedocs.org/en/v3.3.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.3.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/09/20/libcloud-3-2-0-released.html">Libcloud 3.2.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Sep 20, 2020</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.2.0.</p>

<p>This release includes various improvements and bug fixes.</p>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-2-0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-2-0</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.2.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.2.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.2.0/">https://libcloud.readthedocs.org/en/v3.2.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.2.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/08/31/miguel-caballer-joins-our-team.html">Miguel Caballer (micafer) joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Aug 31, 2020</span>

  <div class="post-content">
    <p>Please help us extend a warm welcome to our newest team member <a href="https://github.com/micafer">Miguel Caballer</a>!</p>

<p>The Project Management Committee (PMC) for Apache Libcloud has invited Miguel
Caballer to join us as a committer and we are pleased to announce that he
has accepted.</p>

<p>Miguel has been part of the Libcloud community for many years now and during
his participation he made various contributions to the project, majority of
them focusing on our OpenStack drivers.</p>

<p>For anyone who would like to know more about Miguel here is his short bio:</p>

<blockquote>
  <p>Miguel Caballer is part of the Grid and High Performance Computing group of
UPV since 2001. He is the lead developer of the Infrastructure Manager (IM),
a tool that deploys complex and customized virtual infrastructures on IaaS
Cloud deployments. He has participated in different research projects about
the application of Grid and Cloud computing techniques to several areas of
engineering. Other fields of interest include green computing.</p>
</blockquote>

<p>And in his own words:</p>

<blockquote>
  <p>When I start the development of the IM (in python) I found that Libcloud was
the best option to connect with different cloud back-ends using a single
library and using the same basic set of functions calls. It has improved a
lot in the last years adding extra functionality for each connector that makes
it a really good alternative to native libraries. My main contributions has been
mainly related with the OpenStack driver, one of the most user cloud providers
by the IM tool. I’m very proud to be an Apache Libcloud team member and I will
continue with my contributions.</p>
</blockquote>


  </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/new-committer.html" rel="tag">new committer</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/08/02/latest-provider-pricing-data-available-in-s3-bucket.html">Latest up to date provider pricing.json data file is now available in an S3 bucket</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Aug 02, 2020</span>

  <div class="post-content">
    <p>Recently we added a new job to our CI / CD which runs daily and retrieves latest
pricing data for various providers and publishes pricing.json file which can be
used by Libcloud to a public read-only S3 bucket.</p>

<p>More information on where to download it and how to use this file can be found in
<a href="https://libcloud.readthedocs.io/en/latest/compute/pricing.html#downloading-latest-pricing-data-from-an-s3-bucket">our documentation</a>.</p>

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

<p>In the past, we ran the script which updates pricing.json file which is bundled
with each Libcloud release just before publishing a new release.</p>

<p>The problem is that the pricing data can change often, so updating it only once
every couple of months as part of a Libcloud release is not sufficient.</p>

<p>To solve for that problem, we now update and publish pricing.json file which
includes latest retrieved pricing data for various providers on a daily basis.</p>

<p>It’s worth noting that we can’t guarantee 100% accuracy of this data so you
should only use this data as estimate and you should never rely solely on
Libcloud pricing data.</p>

<h2 id="thanks">Thanks</h2>

<p>We would like to extend special thanks to <a href="https://github.com/Eis-D-Z">Eis D. Zaster</a> who has
contributed new scraping scripts for multiple providers and also made
various improvements and fixes to the existing scraping scripts.</p>

<p>In addition to that, we would like to thank <a href="https://aws.amazon.com/blogs/opensource/aws-promotional-credits-open-source-projects/">Amazon Web Services</a> which
granted us free credits for their EC2 and S3 service which we plan to use
for hosting this pricing file, end to end tests and more.</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/pricing-data.html" rel="tag">pricing data</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/06/12/libcloud-3-1-0-released.html">Libcloud 3.1.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jun 12, 2020</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.1.0.</p>

<p>This release includes various improvements and bug fixes.</p>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.1.0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3.1.0</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.1.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.1.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.1.0/">https://libcloud.readthedocs.org/en/v3.1.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.1.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/06/12/libcloud-2-8-3-released.html">Libcloud 2.8.3 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jun 12, 2020</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v2.8.3.</p>

<p>This is a bug-fix only release in the v2.8.x release. It includes two bug fixes.</p>

<p>A list of all the changes can be found at
<a href="https://github.com/apache/libcloud/blob/2.8.x/CHANGES.rst">https://github.com/apache/libcloud/blob/2.8.x/CHANGES.rst</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==2.8.3"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==2.8.3"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.8.3/">https://libcloud.readthedocs.org/en/v2.8.3/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.8.3/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/04/15/libcloud-3-0-0-released.html">Libcloud 3.0.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Apr 15, 2020</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.0.0.</p>

<p>This is the first release in the v3.x.x series. It includes many changes
and improvements, the biggest one being dropping support for Python 2.7 and
Python 3 &lt; 3.5.</p>

<p>If you still need to use Python 2.7 or Python 3 &lt; 3.5 you can use Libcloud
v2.8.x release series which still supports those Python versions - keep in
mind though that this release series only includes bug fixes. All the new
features and improvements will land in the v3.x.x series.</p>

<p>Other highlights include:</p>

<ul>
  <li>Type annotations for the base storage API</li>
  <li>Various improvements in the Azure Blobs driver</li>
  <li>New standard “prefix” keyword argument in the <code class="language-plaintext highlighter-rouge">{list,iterate}_container_objects</code>
methods</li>
  <li>4 new compute drivers (KubeVirt, LXD, Kamatera, GiG G8)</li>
  <li>Various improvements to the <code class="language-plaintext highlighter-rouge">deploy_node()</code> functionality</li>
  <li>and much more</li>
</ul>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-0-0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-0-0</a> and
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-0-0-rc1">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-0-0-rc1</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.0.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.0.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.0.0/">https://libcloud.readthedocs.org/en/v3.0.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.0.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/04/15/libcloud-2-8-2-released.html">Libcloud 2.8.2 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Apr 15, 2020</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v2.8.2.</p>

<p>This release includes a couple of bug fixes and small improvements for
the <code class="language-plaintext highlighter-rouge">deploy_node()</code> functionality.</p>

<p>Keep in mind that v2.8.x is a bug-fix only release series. All the other
new features and improvements are available in v3.0.0 release which
drops support for Python &lt; 3.5.</p>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2.8.2">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2.8.2</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==2.8.2"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==2.8.2"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.8.2/">https://libcloud.readthedocs.org/en/v2.8.2/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.8.2/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/03/03/libcloud-2-8-1-released.html">Libcloud 2.8.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Mar 03, 2020</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v2.8.1.</p>

<p>This release includes various bug-fixes which have accumulated in trunk since
the last release.</p>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2-8-1">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2-8-1</a>.</p>

<p>Keep in mind that 2.8.x is purely a bug fix release series. New features and
improvements will be added to the upcoming 3.x.x release series which
only support Python 3.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==2.8.1"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==2.8.1"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.8.1/">https://libcloud.readthedocs.org/en/v2.8.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.8.1/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/01/29/libcloud-3-0-0-rc1-released.html">Libcloud 3.0.0-rc1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 29, 2020</span>

  <div class="post-content">
    <p>We are happy to announce Libcloud v3.0.0-rc1.</p>

<p>This is the first release candidate for Libcloud v3.0.0 which includes many 
changes, the biggest one being dropping support for Python 2.7 and 
Python 3 &lt; 3.5.</p>

<p>Since this is a first release which drops support for those Python versions,
we want to give our users some time to opt-in and test it and verify
everything works as expected, before we produce a stable v3.0.0 release.</p>

<p>Other highlights include:</p>

<ul>
  <li>Type annotations for the base storage API</li>
  <li>Various improvements in the Azure Blobs driver</li>
  <li>New standard “prefix” keyword argument in the <code class="language-plaintext highlighter-rouge">{list,iterate}_container_objects</code>
methods</li>
  <li>2 new compute drivers (KubeVirt, LXD)</li>
</ul>

<p>If no major issues are found, this release candidate (with any other fixes
which accumulate in trunk until then) will become a stable v3.0.0 release
some time in the near future.</p>

<p>Keep in mind that this is a pre-release so it won’t be installed by pip
by default when you run <code class="language-plaintext highlighter-rouge">pip install apache-libcloud</code>.</p>

<p>To install it, you need to explicitly specify a version as shown in the
Download section below.</p>

<p>A list of all the changes can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-0-0-rc1">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-3-0-0-rc1</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==3.0.0rc-1"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==3.0.0rc-1"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v3.0.0-rc1/">https://libcloud.readthedocs.org/en/v3.0.0-rc1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.</p>

<p>Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v3.0.0-rc1/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2020/01/02/libcloud-2-8-0-released.html">Libcloud 2.8.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 02, 2020</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.8.0.</p>

<p>This release includes various changes, most notable ones being:</p>

<ul>
  <li>Distribution now includes <code class="language-plaintext highlighter-rouge">py.typed</code> file which signals mypy that
this package contains type annotations (currently only for the
base compute API).</li>
  <li>Fix wheel metadata. There was a bug where conditional dependencies
were not specified correctly so it would try to install <code class="language-plaintext highlighter-rouge">typing</code>
and <code class="language-plaintext highlighter-rouge">enum34</code> dependency on Python versions where there is not needed.</li>
  <li>Fix <code class="language-plaintext highlighter-rouge">get_driver()</code> bug / regression not working if the <code class="language-plaintext highlighter-rouge">provider</code>
argument was a string and not a Provider ENUM.</li>
</ul>

<p>Full change log can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2-8-0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2-8-0</a>.</p>

<h3 id="dropping-support-for-python-27-and-python-34">Dropping support for Python 2.7 and Python 3.4</h3>

<p>The plan was for v2.7.0 to be the last major release before v3.0.0 which
drops support for Python 2.7 and Python 3.4, but this has changed since
v2.7.0 introduced some small regressions / bugs which needed to be fixed.</p>

<p>If no major issues are found in this release, this will be the
last release before v3.0.0 which drops support for those Python
versions.</p>

<p>For more information on dropping support for Python 2.7 and Python 3.4, please
refer to the v2.7.0 release announcement
<a href="https://libcloud.apache.org/blog/2019/12/09/libcloud-2-7-0-released.html">https://libcloud.apache.org/blog/2019/12/09/libcloud-2-7-0-released.html</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install "apache-libcloud==2.8.0"
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade "apache-libcloud==2.8.0"
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.8.0/">https://libcloud.readthedocs.org/en/v2.8.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.8.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2019/12/09/libcloud-2-7-0-released.html">Libcloud 2.7.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 09, 2019</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.7.0.</p>

<p>Among various smaller bug fixes, this release also includes a couple of big
new features.</p>

<p>Highlights include:</p>

<ul>
  <li>Initial type annotations / hints support for the base Libcloud compute API.</li>
  <li>S3 driver class has been updated to support <code class="language-plaintext highlighter-rouge">region</code> argument in the same
manner as other drivers which support multiple regions (no more messy class
per region approach). For backward compatibility reasons, “class per region”
approach will still be supported until the next major release.</li>
  <li>New <code class="language-plaintext highlighter-rouge">start_node()</code> and <code class="language-plaintext highlighter-rouge">stop_node()</code> method have been added to the base
Libcloud compute API and the existing drivers which implement
<code class="language-plaintext highlighter-rouge">ex_start_node()</code> and <code class="language-plaintext highlighter-rouge">ex_stop_node()</code> methods have been updated to
implement those new methods. Old <code class="language-plaintext highlighter-rouge">ex_</code> methods will continue to work for
backward compatibility reasons.</li>
</ul>

<p>Full change log can be found at
<a href="https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2-7-0">https://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-v2-7-0</a>.</p>

<h3 id="dropping-support-for-python-27-and-python-34">Dropping support for Python 2.7 and Python 3.4</h3>

<p>Libcloud was among some of the other early larger Python projects which have
supported Python 2.x and Python 3.x simultaneously using a single code base
from 2011.</p>

<p>Over the years, the landscape has changed a lot. A lot of the users now use
Python 3 as a default and a lot of the popular Python projects now not only
support Python 3, but also make Python 3 the only supported Python version.</p>

<p>In addition to that, <a href="https://pythonclock.org/">Python 2.7 will not be maintained past January 2020</a>.</p>

<p>We have decided to sign the <a href="https://python3statement.org/">Python 3 statement</a> and drop support for Python
2.7 and Python 3.4 in the next major release (v3.0.0) which will coincide
with Python 2.7 EOL early next year.</p>

<p>This means that Libcloud v2.7.0 will be the last major release which still
supports Python 2.7 and 3.4.</p>

<p>The change itself is still work in progress. People who are interested in it
can check the following PR <a href="https://github.com/apache/libcloud/pull/1377">https://github.com/apache/libcloud/pull/1377</a>.</p>

<h4 id="how-does-this-affect-me">How does this affect me?</h4>

<p>If you still need to use Python 2.7 or Python 3.4 after Libcloud v3.0.0 is
out, you will be able to do that by utilizing one of the older Libcloud
releases which still supports that Python version.</p>

<p>All the new feature development and improvements will land in new release
which support Python &gt;= 3.5 only, but we may still do a release in the
v2.7.x release series if a major bug or a security issue is found.</p>

<h4 id="how-does-this-affect-the-libcloud-development-team">How does this affect the Libcloud development team?</h4>

<p>Supporting Python 2.x and Python 3.x through a single code base was never
totally trivial.</p>

<p>This is especially true for our project which doesn’t use <code class="language-plaintext highlighter-rouge">six</code> Python 2
/ 3 compatibility library, but uses custom glue / wrapper code for that.</p>

<p>There are multiple reasons why we didn’t use <code class="language-plaintext highlighter-rouge">six</code> - one is that we still
needed to support Python 2.5 which is not supported by <code class="language-plaintext highlighter-rouge">six</code> and another
one is that we didn’t want to introduce another dependency on the end user in
the days where Python packaging was still very much in the infancy.</p>

<p>Dropping support for Python 2.7 and Python 3.4 will allow us to streamline our
code and remove a lot of the code which is not needed anymore.</p>

<p>This will result in easier development and cleaner code.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.7.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.7.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.7.0/">https://libcloud.readthedocs.org/en/v2.7.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.7.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2019/11/18/libcloud-2-6-1-released.html">Libcloud 2.6.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 18, 2019</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.6.1!</p>

<p>This release includes various small bug fixes and improvements.</p>

<p>Full change log can be found at
<a href="http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2.6.1">http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2.6.1</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.6.1
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.6.1
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.6.1/">https://libcloud.readthedocs.org/en/v2.6.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.6.1/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2019/08/28/libcloud-2-6-0-released.html">Libcloud 2.6.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Aug 28, 2019</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.6.0!</p>

<p>This release includes many new features and improvements. Highlights
include:</p>

<ul>
  <li><a href="https://libcloud.readthedocs.io/en/latest/compute/drivers/gridscale.html">New compute driver for Gridscale.io provider</a></li>
  <li>New compute driver for Maxihost provider</li>
  <li>Various improvements in the OpenStack compute driver</li>
  <li><a href="https://libcloud.readthedocs.io/en/latest/other/using-http-proxy.html">Support for <code class="language-plaintext highlighter-rouge">https</code> proxies</a></li>
  <li>Various improvements in the Azure blobs storage driver</li>
  <li>Various improvements to the deploy node functionality and handling of
unsupported SSH key types</li>
  <li>CloudFlare DNS driver has been updated to use CloudFlare API v4</li>
  <li>and much more.</li>
</ul>

<p>Full change log can be found at
<a href="http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2.6.0">http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2.6.0</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.6.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.6.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.6.0/">https://libcloud.readthedocs.org/en/v2.6.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://github.com/apache/libcloud/issues">https://github.com/apache/libcloud/issues</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.6.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2019/08/27/clemens-wolff-joins-our-team.html">Clemens Wolff (clewolff) joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Aug 27, 2019</span>

  <div class="post-content">
    <p>Please help us extend a warm welcome to our newest team member <a href="https://github.com/c-w">Clemens
Wolff</a>!</p>

<p>The Project Management Committee (PMC) for Apache Libcloud has invited Clemens
Wolff to join us as a committer and we are pleased to announce that he
has accepted.</p>

<p>Clemens has participated in the Libcloud community for a while now and during
his participation he made a <a href="https://github.com/apache/libcloud/pulls?q=is%3Apr+author%3Ac-w">number of high quality contributions to the
project</a>.</p>

<p>For anyone who would like to know more about Clemens here is his short bio:</p>

<blockquote>
  <p>Clemens Wolff is a tech lead in Microsoft’s Commercial Software
Engineering team, enabling customers from around the world to create scalable,
resilient and efficient software solutions applying relevant technologies and
platforms, including cloud computing, highly scalable data engines, machine
learning and analytics, and distributed messaging systems.</p>
</blockquote>

<p>And in his own words:</p>

<blockquote>
  <p>I was introduced to Libcloud while working with a research group at Imperial
College London on porting OKpy, an open source computer science classroom
management system, from GCP to Azure. OKpy uses Libcloud which made
migrating the object storage needs of the application a breeze. Since this
initial exposure, I’ve been using Libcloud on many projects to ensure
cross-cloud compatibility and to simplify testing via the local provider
implementations. Most of my contributions have been about maintaining and
updating the Azure implementation of Libcloud’s storage driver and
building test automation to ensure that Libcloud can seamlessly be used
with Azure.</p>
</blockquote>

<p>We are happy to have him in our team and we are looking forward to his future
participation and contributions.</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/new-committer.html" rel="tag">new committer</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2019/05/30/libcloud-2-5-0-released.html">Libcloud 2.5.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on May 30, 2019</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.5.0!</p>

<p>This release includes various improvements and additions to the
OpenStack driver, new compute and load balancers drivers for
NTT-CIS cloud and more.</p>

<p>Full change log can be found at
<a href="http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-5-0">http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-5-0</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.5.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.5.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.5.0/">https://libcloud.readthedocs.org/en/v2.5.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.5.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2018/11/08/libcloud-2-4-0-released.html">Libcloud 2.4.0 released</a></h2>
  
  <span class="post-date-author">By Quentin Pradet on Nov 08, 2018</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.4.0!</p>

<p>The most notable change is Python 3.7 support. There is also a new
Scaleway driver, and improvements for many other drivers.</p>

<p>Full change log can be found at
<a href="http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-4-0">http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-4-0</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.4.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.4.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.4.0/">https://libcloud.readthedocs.org/en/v2.4.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.4.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2018/06/27/rick-van-de-loo-joins-our-team.html">Rick van de Loo (vdloo) joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jun 27, 2018</span>

  <div class="post-content">
    <p>Please help us extend a warm welcome to our newest team member <a href="https://github.com/vdloo">Rick van de
Loo</a>!</p>

<p>The Project Management Committee (PMC) for Apache Libcloud has invited Rick
van de Loo to join us as a committer and we are pleased to announce that he
has accepted.</p>

<p>In the last couple of years Rick has <a href="https://github.com/apache/libcloud/pulls?q=is%3Apr+author%3Avdloo+is%3Aclosed">contributed various high quality
changes</a> to the project and we are happy to have him on board.</p>

<p>For anyone who would like to know more about Rick here is his short bio:</p>

<blockquote>
  <p>Rick van de Loo is the lead developer on Hypernode, a highly automated and
cloud agnostic hosting platform specialised for Magento built on top of Apache
Libcloud. Since Rick started working on Hypernode he has seen it scale from
double digits to thousands of servers, along the road orchestrating various
high volume cross-provider migrations. His main focus is on platform
stability and feature development, of which a large part has been integrating
cloud APIs and working around their incompatibilities and unreliable nature.</p>
</blockquote>

<p>And in his own words:</p>

<blockquote>
  <p>Since we started using Libcloud around four years ago the landscape has
changed a lot. But even though container-based and serverless architectures
have become more prominent, compute is still the cornerstone of cloud. Most
of my contributions have been about standardising functionality across
different compute providers and implementing new driver methods, mainly
related to the AWS, DigitalOcean and OpenStack APIs. As an Apache Libcloud
team member I will continue to contribute changes that help us scratch our
own itch and encourage other members of the Hypernode team to do the same.</p>
</blockquote>

<p>We are happy to have him in our team and we are looking forward to his future
participation and contributions.</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/new-committer.html" rel="tag">new committer</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2018/03/03/libcloud-2-3-0-released.html">Libcloud 2.3.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Mar 03, 2018</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.3.0!</p>

<p>Most notable changes are the dropping of support for Python 2.6 and 3.3,
both of which are now unsupported distributions.</p>

<p>There are new drivers for UpCloud, Digital Ocean Spaces, bug fixes and
improvements for many other drivers.</p>

<p>Full change log can be found at
<a href="http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-3-0">http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-3-0</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.3.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.3.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.3.0/">https://libcloud.readthedocs.org/en/v2.3.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.3.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2017/12/30/libcloud-year-in-review-2017-released.html">Libcloud Year in Review 2017</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 30, 2017</span>

  <div class="post-content">
    <p>Another year is behind us. Like most of the previous years, this year included
a lot of exciting development. This post is going to present some statistics and
highlights of the year.</p>

<h3 id="year-in-numbers-recap">Year in Numbers (recap)</h3>

<ul>
  <li>800+ commits</li>
  <li>191 opened PRs on Github (159 closed, 32 open at the time of this writing)</li>
  <li>86 opened JIRA issues</li>
  <li>75+ different contributors</li>
  <li>4 releases (3 major ones)</li>
</ul>

<div class="imginline">
  <p><a href="https://www.openhub.net/p/libcloud" target="_blank"><img src="/images/posts/2017-12-30-libcloud-year-in-review-2017-released/Screenshot from 2017-12-29 19-07-48.png" class="img-responsive inline" /></a></p>
  <p class="img-caption">Statistics from Open Hub.</p>
</div>

<p>You can also dig into the numbers yourself on <a href="https://github.com/apache/libcloud/pulse">Github</a>, <a href="https://www.openhub.net/p/libcloud">Open Hub</a> and
<a href="https://projects.apache.org/project.html?libcloud">Apache Project Information</a>.</p>

<h2 id="releases">Releases</h2>

<p>This year we had 4 releases (2.0.0, 2.1.0, 2.2.0, 2.2.1). Out of that, three
major ones.</p>

<p>Libcloud 2.0.0 which was released in April represented a big milestone. We
finally moved away from our home grown HTTP abstraction layer built on top
of Python’s httplib library to the popular requests library.</p>

<p>Back in the day when the project started, requests library didn’t exist yet so
we needed to build a lot of the functionality which is now provided by requests
ourselves. Move to requests means that we now have a lot less code to maintain
and we can focus our efforts on the actual drivers which is core to Libcloud and
where the project provides value.</p>

<p>To give you an idea how much effort it took - the ground work for that change
started back in 2016 (<a href="https://libcloud.apache.org/blog/2016/04/06/requests-support.html">https://libcloud.apache.org/blog/2016/04/06/requests-support.html</a>,
<a href="https://github.com/apache/libcloud/pull/728">https://github.com/apache/libcloud/pull/728</a>), but it took a lot more testing
and work to get it stable enough so we were finally able to include it as part
of the stable 2.0.0 release (and before that, we also released a couple of release
candidates so users could test and verify that their Libcloud related code
still works as expected without any regressions).</p>

<p>Special thanks to <a href="https://twitter.com/anthonypjshaw?lang=en">Anthony Shaw</a> for leading this effort and not giving up (the
change itself involved touching a lot of code and updating test cases for most
of the drivers which resulted in a lot of not so pleasant work and merge
conflicts).</p>

<h2 id="community">Community</h2>

<p>The community continued to grow and we have received contributions from more
than 75 different contributors. Keep in mind that this number only includes
people who contributed a code change which has been merged into trunk. The
actual number is quite a bit higher (code who didn’t get merged, people who
reported a bug or didn’t include a code change, etc).</p>

<p>We have also added one new committer - Quentin Pradet.</p>

<h2 id="ecosystem">Ecosystem</h2>

<p>In addition to various proprietary and private code bases, Libcloud continues
to be used as an important part by various open-source <a href="https://pypi.python.org/pypi?%3Aaction=search&amp;term=libcloud&amp;submit=search">projects and
libraries</a>.</p>

<p>Most notable ones include <a href="https://saltstack.com/">SaltStack</a>, <a href="https://stackstorm.com/">StackStorm</a> and <a href="https://www.google.si/search?ei=bqVGWvyGMYOXkwWlgI7gCw&amp;q=ansible&amp;oq=ansible&amp;gs_l=psy-ab.3..0i67k1j0l9.2982.2982.0.3130.1.1.0.0.0.0.99.99.1.1.0....0...1c.1.64.psy-ab..0.1.99....0.4KRxU06xPjw">Ansible</a>.</p>

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

<p>I would like to take this opportunity to thank everyone who has contributed
to the project in one form or another. No matter how small or involved, your
contribution helped project grow and push through another successful year.</p>

<p>Again, thank you, happy and successful 2018 and see you soon.</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/year-in-review.html" rel="tag">year in review</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2017/09/21/libcloud-2-2-1-released.html">Libcloud 2.2.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Sep 21, 2017</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.2.1!</p>

<p>This is a first patch release in the 2.2.x series and as such, it
includes some bug fixes and improvements.</p>

<p>The most important one of them fixes an installation of Libcloud 2.2.0
failing on some operating-system and file-system combinations (e.g.
ecryptfs layered on top of ext3/4) which don’t support file names longer
than 143 characters.</p>

<p>In addition to that, it also includes performance improvement for the
deploy functionality available to the compute drivers. Now the deploy
scripts which produce a lot of output should finish a lot faster.</p>

<p>Full change log can be found at
<a href="http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-2-1">http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-2-1</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.2.1
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.2.1
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.2.1/">https://libcloud.readthedocs.org/en/v2.2.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.2.1/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2017/09/03/libcloud-2-2-0-released.html">Libcloud 2.2.0 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Sep 03, 2017</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.2.0!</p>

<p>The release includes a new improvements to Azure ARM support, fixes for
Route 53 users, and support for TLS authenticated Docker drivers.</p>

<p>Full change log can be found at
<a href="http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2.2.0">http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2.2.0</a>.</p>

<p>All of our community for their ongoing support and contributions…</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.2.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.2.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.2.0/">https://libcloud.readthedocs.org/en/v2.2.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.2.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2017/07/17/libcloud-2-1-0-released.html">Libcloud 2.1.0 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Jul 17, 2017</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.1.0!</p>

<p>The release includes a new driver for Google Container Engine (GKE),
upgrades to the OpenStack driver to support keystone v3 and Nova v2.x</p>

<p>Full change log can be found at
<a href="http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-1-0">http://libcloud.readthedocs.io/en/latest/changelog.html#changes-in-apache-libcloud-2-1-0</a>.</p>

<p>All of our community for their ongoing support and contributions…</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.1.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.1.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v2.1.0/">https://libcloud.readthedocs.org/en/v2.1.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/v2.1.0/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2017/04/25/libcloud-2-0-0-released.html">Libcloud 2.0.0 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Apr 25, 2017</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.0.0.</p>

<p>This major release brings many new features, improvements, bug-fixes, and drivers.</p>

<h2 id="release-highlights">Release highlights</h2>

<ul>
  <li>Apache Libcloud 2.0 series replaces the use of Python httplib with a hard dependency on the <code class="language-plaintext highlighter-rouge">requests</code> package. Users no longer
have to specific Certificate Authority bundles when using Apache Libcloud</li>
  <li>10% performance improvement through the use of HTTP sessions</li>
  <li>Support for buffered IO streams for storage drivers</li>
  <li>Support for Python 3.6, deprecation of Python 3.2</li>
  <li>3 new drivers - <a href="http://libcloud.readthedocs.io/en/latest/compute/drivers/onapp.html">OnApp Compute</a>, <a href="http://libcloud.readthedocs.io/en/latest/dns/drivers/onapp.html">OnApp DNS</a>, <a href="http://libcloud.readthedocs.io/en/latest/compute/drivers/oneandone.html">1&amp;1 Compute</a></li>
  <li>Lots of improvements to our Azure ARM support</li>
  <li>Continuing udates to the Amazon drivers</li>
</ul>

<p>A detailed description of the 2.0 HTTP API is documented <a href="http://libcloud.readthedocs.io/en/latest/other/changes_in_2_0.html">here</a></p>

<h3 id="compute-api-changes">Compute API Changes</h3>

<ul>
  <li>Outscale SAS doc improvements and logo update</li>
</ul>

<h4 id="onapp-changes">OnApp Changes</h4>

<ul>
  <li>Add list images support for OnApp driver</li>
  <li>Add keypair management to OnApp driver</li>
</ul>

<h4 id="amazon-ec2-changes">Amazon EC2 Changes</h4>

<ul>
  <li>Add r4 instance types for AWS</li>
  <li>Add support for AWS eu-west-2 and ca-central-1 regions</li>
  <li>Add P2 GPU instance types</li>
  <li>Add method to modify snapshot attribute for EC2</li>
  <li>Add ENA support for EC2 compute images</li>
  <li>Add support for forcing detachment of EBS volumes to EC2 driver</li>
  <li>Add support for ModifyVolume and DescribeVolumesModifications</li>
  <li>Added Import Snapshot and Describe Import Snapshot to EC2 compute driver</li>
  <li>Add missing regions in AWS storage and compute drivers</li>
  <li>Add SR-IOV net support to images in EC2 compute driver</li>
  <li>Fix - update t2.small image size from 11 CPU to 1</li>
  <li>Added Billing Product for image in EC2 compute driver</li>
</ul>

<h4 id="linode-changes">Linode changes</h4>

<ul>
  <li>Add start, stop instance methods and fix incorrect state TERMINATED to STOPPED</li>
</ul>

<h4 id="azure-arm-changes">Azure ARM changes</h4>

<ul>
  <li>Fix typeerror on ex_list_nics</li>
  <li>Add support for Azure Cloud Environments as well as Locations</li>
  <li>Fix string representation of the VhdImage type and fix listing of Public IP addresses</li>
  <li>Add network security groups to azure ARM</li>
  <li>Add the ability to list resource groups</li>
  <li>Fix Azure ARM driver condition for ex_list_publishers where location is specified</li>
</ul>

<h4 id="google-cloud-changes">Google Cloud changes</h4>

<ul>
  <li>Allow delete instances from managed group</li>
  <li>Allow preemptible instances to be created</li>
  <li>Remove validation checks for guestOsFeatures</li>
</ul>

<h4 id="alibaba-aliyun-changes">Alibaba Aliyun changes</h4>

<ul>
  <li>Add aliyun ecs instance join leave security group</li>
  <li>Fix Aliyun ECS, Load balancer and storage adapters when using unicode UTF-8 characters in the names of resources</li>
</ul>

<h4 id="digitalocean-changes">DigitalOcean changes</h4>

<ul>
  <li>Add price_monthly extra param to digitalocean sizes</li>
</ul>

<h4 id="vmware-vsphere-changes">VMWare vSphere changes</h4>

<ul>
  <li>Fix issue with authentication methods crashing</li>
</ul>

<h3 id="storage">Storage</h3>

<ul>
  <li>Reintroduce S3 multipart upload support with signature v4</li>
</ul>

<h3 id="dns">DNS</h3>

<ul>
  <li>Add <a href="http://libcloud.readthedocs.io/en/latest/dns/drivers/onapp.html">OnApp driver</a></li>
</ul>

<h2 id="minor-changes">Minor changes</h2>

<h3 id="common">Common</h3>

<ul>
  <li>Added an integration test API and a test suite for validating functionality
without mocking any libcloud subsystems</li>
  <li>Change Cloudscale to cloudscale.ch.</li>
</ul>

<h2 id="bug-fixes">Bug Fixes</h2>

<h3 id="compute">Compute</h3>

<h4 id="200">2.0.0</h4>

<ul>
  <li>
    <p>Fix OpenStack drivers not correctly setting URLs when used with identity API, would default to 127.0.0.1 and service
catalog URLs were not adhered to.</p>
  </li>
  <li>
    <p>Fix Aliyun ECS, Load balancer and storage adapters when using unicode UTF-8 characters in the names of resources
in 2.0.0rc2 &lt; it would fail as a MalformedResponseError, Python 2.7 element tree was raising a unicode error</p>
  </li>
  <li>
    <p>Refactor the test classes to use the full libcloud.http and libcloud.common.base modules, with Connection,
Response all used with requests_mock. This increases our test coverages and catches bugs in drivers’ custom
parse_body and auth modules</p>
  </li>
  <li>
    <p>Rename libcloud.httplib_ssl to libcloud.http now that we don’t use httplib</p>
  </li>
</ul>

<h4 id="200rc2">2.0.0rc2</h4>

<ul>
  <li>Fix Public IP not assigned when creating NIC on Azure ARM</li>
  <li>Fix a bug in profitbricks driver where listing snapshots would request a malformed URL</li>
  <li>Fix LIBCLOUD-806 bug where vsphere driver cannot be instantiated</li>
  <li>[google compute] Improve performance of list nodes by caching volume information.</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="special-thank-you">Special thank you</h3>

<p>I would like to wish a special thank you to all of our community contributors
for their ongoing support to the project.</p>

<ul>
  <li>Tinu Cleatus for the OnApp driver</li>
  <li>Alex Misstear for the EC2 improvements</li>
  <li>Jie Ren for the Aliyun improvements</li>
  <li>Francisco Ros for the DigitalOcean improvements</li>
  <li>Peter Amstutz and Joseph Hall for the Azure ARM API updates</li>
  <li>All of our community for their ongoing support and contributions…</li>
</ul>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.0.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.0.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2017/04/09/async-rfc.html">Have your say - async support in Apache Libcloud</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Apr 09, 2017</span>

  <div class="post-content">
    <p>One of the big requests whilst we were replacing <code class="language-plaintext highlighter-rouge">httplib</code> with the <code class="language-plaintext highlighter-rouge">requests</code> package in 2.0 was why didn’t
we use a HTTP library that supports <em>asynchronous</em> API calls.</p>

<p>The intention for 2.0 and replacing the HTTP backend classes was to improve the usability of the project, by making SSL
certificates easier to manage, improving the maintainability of our source code by using an active 3rd party package and
also improving performance and stability.</p>

<p>Apache Libcloud already has documentation on threaded libraries like gevent and callback-based libraries like Twisted, see
<a href="https://libcloud.readthedocs.io/en/latest/other/using-libcloud-in-multithreaded-and-async-environments.html">using libcloud in multithreaded environments</a>
for examples.</p>

<p><a href="https://www.python.org/dev/peps/pep-0492/#">PEP 492</a>, implemented in Python 3.5 provides a new coroutine protocol using methods,
<code class="language-plaintext highlighter-rouge">__await__</code> for classes, a coroutine method wrapper, or a method that returns a coroutine object.
Also async <a href="https://www.python.org/dev/peps/pep-0492/#asynchronous-iterators-and-async-for">iterators</a> and <a href="https://www.python.org/dev/peps/pep-0492/#asynchronous-context-managers-and-async-with">context managers</a>
have been introduced.</p>

<p>We would like to take advantage of the new language features by offering APIs in Apache Libcloud without breaking backward compatibility and
compatibility for users of &lt;Python 3.5.</p>

<p>Use cases for this would be:</p>

<ul>
  <li>Being able to fetch <code class="language-plaintext highlighter-rouge">Node</code> or <code class="language-plaintext highlighter-rouge">StorageObject</code>s from multiple geographies or drivers simultaneously.</li>
  <li>Being able to quickly upload or download storage objects by parallelizing operations on the <code class="language-plaintext highlighter-rouge">StorageDriver</code>.</li>
  <li>Being able to call a long-running API method (e.g. generate report), whilst running other code.</li>
</ul>

<h2 id="design-1---async-context-managers-pr-1016">Design 1 - async context managers <a href="https://github.com/apache/libcloud/pull/1016">PR 1016</a></h2>

<p>This design would allow drivers to operate in 2 modes, the first is for synchronous method calls, they return list or object
data as per usual. The second mode, API methods like <code class="language-plaintext highlighter-rouge">NodeDriver.list_nodes</code> would return a <a href="https://www.python.org/dev/peps/pep-0492/#coroutine-objects">coroutine object</a>
and could be awaited or gathered using an event loop.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="kn">import</span> <span class="nn">asyncio</span>

<span class="kn">from</span> <span class="nn">integration.driver.test</span> <span class="kn">import</span> <span class="n">TestNodeDriver</span>
<span class="kn">from</span> <span class="nn">libcloud.async_util</span> <span class="kn">import</span> <span class="n">AsyncSession</span>

<span class="n">driver</span> <span class="o">=</span> <span class="n">TestNodeDriver</span><span class="p">(</span><span class="s">'apache'</span><span class="p">,</span> <span class="s">'libcloud'</span><span class="p">)</span>

<span class="k">async</span> <span class="k">def</span> <span class="nf">run</span><span class="p">():</span>
    <span class="c1"># regular API call
</span>    <span class="n">nodes</span> <span class="o">=</span> <span class="n">driver</span><span class="p">.</span><span class="n">list_nodes</span><span class="p">()</span>

    <span class="k">async</span> <span class="k">with</span> <span class="n">AsyncSession</span><span class="p">(</span><span class="n">driver</span><span class="p">)</span> <span class="k">as</span> <span class="n">async_instance</span><span class="p">:</span>
        <span class="n">nodes</span> <span class="o">=</span> <span class="k">await</span> <span class="n">async_instance</span><span class="p">.</span><span class="n">list_nodes</span><span class="p">()</span>

    <span class="k">assert</span> <span class="nb">len</span><span class="p">(</span><span class="n">nodes</span><span class="p">)</span> <span class="o">==</span> <span class="mi">2</span>

<span class="n">loop</span> <span class="o">=</span> <span class="n">asyncio</span><span class="p">.</span><span class="n">get_event_loop</span><span class="p">()</span>
<span class="n">loop</span><span class="p">.</span><span class="n">run_until_complete</span><span class="p">(</span><span class="n">run</span><span class="p">())</span>
<span class="n">loop</span><span class="p">.</span><span class="n">close</span><span class="p">()</span>
</code></pre>
  </div>
</div>

<h2 id="design-2---additional-methods-in-each-driver-for-coroutines-pr-1027">Design 2 - Additional methods in each driver for coroutines <a href="https://github.com/apache/libcloud/pull/1027">PR 1027</a></h2>

<p>This is the second design concept for async support in Libcloud.</p>

<p>The concept here is to have Asynchronous Mixins, <code class="language-plaintext highlighter-rouge">LibcloudConnection</code> uses requests and <code class="language-plaintext highlighter-rouge">LibcloudAsyncConnection</code> uses aiohttp for async transport <a href="https://github.com/tonybaloney/libcloud/blob/d4fe097476d2f02941e17d5e1b1d405fcf44c0f7/libcloud/connection_async.py#L22-L42">see</a></p>

<p>The LibcloudAsyncConnection is an implementation detail of AsyncConnection, which is the API for the drivers to consume <a href="https://github.com/tonybaloney/libcloud/blob/d4fe097476d2f02941e17d5e1b1d405fcf44c0f7/libcloud/common/base.py#L742-L778">see</a></p>

<p>The drivers then use this mixin for their custom connection classes, e.g.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>
<span class="k">class</span> <span class="nc">GoogleStorageConnection</span><span class="p">(</span><span class="n">ConnectionUserAndKey</span><span class="p">,</span> <span class="n">AsyncConnection</span><span class="p">):</span>
    <span class="p">...</span>

</code></pre>
  </div>
</div>

<p>They then inherit from <code class="language-plaintext highlighter-rouge">libcloud.storage.base.StorageAsyncDriver</code>, which uses a new set of base methods, e.g. <code class="language-plaintext highlighter-rouge">iterate_containers_async</code> and can be implemented like this:</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>        <span class="k">async</span> <span class="k">def</span> <span class="nf">iterate_containers_async</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
            <span class="n">response</span> <span class="o">=</span> <span class="k">await</span> <span class="bp">self</span><span class="p">.</span><span class="n">connection</span><span class="p">.</span><span class="n">request_async</span><span class="p">(</span><span class="s">'/'</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">response</span><span class="p">.</span><span class="n">status</span> <span class="o">==</span> <span class="n">httplib</span><span class="p">.</span><span class="n">OK</span><span class="p">:</span>
                <span class="n">containers</span> <span class="o">=</span> <span class="bp">self</span><span class="p">.</span><span class="n">_to_containers</span><span class="p">(</span><span class="n">obj</span><span class="o">=</span><span class="n">response</span><span class="p">.</span><span class="nb">object</span><span class="p">,</span>
                                                 <span class="n">xpath</span><span class="o">=</span><span class="s">'Buckets/Bucket'</span><span class="p">)</span>
                <span class="k">return</span> <span class="n">containers</span>
    
            <span class="k">raise</span> <span class="n">LibcloudError</span><span class="p">(</span><span class="s">'Unexpected status code: %s'</span> <span class="o">%</span> <span class="p">(</span><span class="n">response</span><span class="p">.</span><span class="n">status</span><span class="p">),</span>
                                <span class="n">driver</span><span class="o">=</span><span class="bp">self</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>Now the consumer can more or less do this:</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="kn">from</span> <span class="nn">libcloud.storage.providers</span> <span class="kn">import</span> <span class="n">get_driver</span>
<span class="kn">from</span> <span class="nn">libcloud.storage.types</span> <span class="kn">import</span> <span class="n">Provider</span>

<span class="kn">import</span> <span class="nn">asyncio</span>

<span class="n">GoogleStorageDriver</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">GOOGLE_STORAGE</span><span class="p">)</span>
<span class="n">driver</span> <span class="o">=</span> <span class="n">GoogleStorageDriver</span><span class="p">(</span><span class="n">key</span><span class="o">=</span><span class="n">KEY</span><span class="p">,</span> <span class="n">secret</span><span class="o">=</span><span class="n">SECRET</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">do_stuff_with_object</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
    <span class="k">print</span><span class="p">(</span><span class="n">obj</span><span class="p">)</span>

<span class="k">async</span> <span class="k">def</span> <span class="nf">run</span><span class="p">():</span>
    <span class="n">tasks</span> <span class="o">=</span> <span class="p">[]</span>
    <span class="k">async</span> <span class="k">for</span> <span class="n">container</span> <span class="ow">in</span> <span class="n">driver</span><span class="p">.</span><span class="n">iterate_containers_async</span><span class="p">():</span>
        <span class="k">async</span> <span class="k">for</span> <span class="n">obj</span> <span class="ow">in</span> <span class="n">driver</span><span class="p">.</span><span class="n">iterate_container_objects_async</span><span class="p">(</span><span class="n">container</span><span class="p">):</span>
            <span class="n">tasks</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">asyncio</span><span class="p">.</span><span class="n">ensure_future</span><span class="p">(</span><span class="n">do_stuff_with_object</span><span class="p">(</span><span class="n">obj</span><span class="p">)))</span>
    <span class="k">await</span> <span class="n">asyncio</span><span class="p">.</span><span class="n">gather</span><span class="p">(</span><span class="o">*</span><span class="n">tasks</span><span class="p">)</span>

<span class="n">loop</span> <span class="o">=</span> <span class="n">asyncio</span><span class="p">.</span><span class="n">get_event_loop</span><span class="p">()</span>
<span class="n">loop</span><span class="p">.</span><span class="n">run_until_complete</span><span class="p">(</span><span class="n">run</span><span class="p">())</span>
<span class="n">loop</span><span class="p">.</span><span class="n">close</span><span class="p">()</span>
</code></pre>
  </div>
</div>

<h2 id="design-3---initializer-with-async-mode">Design 3 - Initializer with “<em>async</em>” mode</h2>

<p>This option is similar to 2, except that if a driver is instantiated with “<code class="language-plaintext highlighter-rouge">async=True</code>”,
then all driver class methods would return coroutine objects. Internally, it would
patch the Connection class with the AsyncConnection class.</p>

<p>The downside of this is that all method calls to a driver would need to be awaited or used
by an event loop.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="kn">from</span> <span class="nn">libcloud.storage.providers</span> <span class="kn">import</span> <span class="n">get_driver</span>
<span class="kn">from</span> <span class="nn">libcloud.storage.types</span> <span class="kn">import</span> <span class="n">Provider</span>

<span class="kn">import</span> <span class="nn">asyncio</span>

<span class="n">GoogleStorageDriver</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">GOOGLE_STORAGE</span><span class="p">)</span>
<span class="n">driver</span> <span class="o">=</span> <span class="n">GoogleStorageDriver</span><span class="p">(</span><span class="n">key</span><span class="o">=</span><span class="n">KEY</span><span class="p">,</span> <span class="n">secret</span><span class="o">=</span><span class="n">SECRET</span><span class="p">,</span> <span class="k">async</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">do_stuff_with_object</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
    <span class="k">print</span><span class="p">(</span><span class="n">obj</span><span class="p">)</span>

<span class="k">async</span> <span class="k">def</span> <span class="nf">run</span><span class="p">():</span>
    <span class="n">tasks</span> <span class="o">=</span> <span class="p">[]</span>
    <span class="k">async</span> <span class="k">for</span> <span class="n">container</span> <span class="ow">in</span> <span class="n">driver</span><span class="p">.</span><span class="n">iterate_containers</span><span class="p">():</span>
        <span class="k">async</span> <span class="k">for</span> <span class="n">obj</span> <span class="ow">in</span> <span class="n">driver</span><span class="p">.</span><span class="n">iterate_container_objects</span><span class="p">(</span><span class="n">container</span><span class="p">):</span>
            <span class="n">tasks</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">asyncio</span><span class="p">.</span><span class="n">ensure_future</span><span class="p">(</span><span class="n">do_stuff_with_object</span><span class="p">(</span><span class="n">obj</span><span class="p">)))</span>
    <span class="k">await</span> <span class="n">asyncio</span><span class="p">.</span><span class="n">gather</span><span class="p">(</span><span class="o">*</span><span class="n">tasks</span><span class="p">)</span>

<span class="n">loop</span> <span class="o">=</span> <span class="n">asyncio</span><span class="p">.</span><span class="n">get_event_loop</span><span class="p">()</span>
<span class="n">loop</span><span class="p">.</span><span class="n">run_until_complete</span><span class="p">(</span><span class="n">run</span><span class="p">())</span>
<span class="n">loop</span><span class="p">.</span><span class="n">close</span><span class="p">()</span>
</code></pre>
  </div>
</div>

<h1 id="give-us-feedback">Give us feedback</h1>

<p>Got a better idea? Have an API or design, the question we’re asking is 
“if you wanted to use Libcloud for an async application, what would the code look like?” This helps us design
the API and the implementation details can follow.</p>

<p>Feel free to comment on the mailing list or on the pull requests, or raise your own pull-request with an API design.</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/tutorial.html" rel="tag">tutorial</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2017/04/07/libcloud-2-0-0-rc2-released.html">Libcloud 2.0.0rc2 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Apr 07, 2017</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 2.0.0rc2.</p>

<p>This release brings many new features, improvements, bug-fixes, and drivers.</p>

<h2 id="release-highlights">Release highlights</h2>

<ul>
  <li>Apache Libcloud 2.0 series replaces the use of Python httplib with a hard dependency on the <code class="language-plaintext highlighter-rouge">requests</code> package. Users’ no longer
have to specific Certificate Authority bundles when using Apache Libcloud</li>
  <li>10% performance improvement through the use of HTTP sessions</li>
  <li>Support for buffered IO streams for storage drivers</li>
  <li>Support for Python 3.6, deprecation of Python 3.2</li>
</ul>

<p>A detailed description of the 2.0 changes is documented <a href="http://libcloud.readthedocs.io/en/latest/other/changes_in_2_0.html">here</a></p>

<p>Note that 2.0.0rc1 was not released to PyPi as 4 breaking issues were discovered by users. The changelog for both 2.0.0rc2 and rc1 is below.</p>

<h2 id="release-highlights-for-200rc2">Release highlights for 2.0.0rc2</h2>

<h3 id="compute">Compute</h3>

<ul>
  <li>Fix a bug in profitbricks driver where listing snapshots would request a malformed URL</li>
  <li>Fix LIBCLOUD-806 bug where vsphere driver cannot be instantiated</li>
  <li>[google compute] Improve performance of list nodes by caching volume information.</li>
</ul>

<h3 id="common">Common</h3>

<ul>
  <li>Fix LIBCLOUD_DEBUG trying to decompress already decompressed responses</li>
  <li>Added an integration test API and a test suite for validating functionality
without mocking any libcloud subsystems</li>
  <li>Fix for Linode classes since 2.0x</li>
  <li>Fix CertificateConnection not correctly signing requests in 2.0rc1, impacted
Azure classic driver, OpenStack and Docker driver</li>
  <li>Change Cloudscale to cloudscale.ch.</li>
  <li>Explicitly check if response is None in RawResponse class</li>
</ul>

<h3 id="compute-1">Compute</h3>

<ul>
  <li>Outscale SAS doc improvements and logo update</li>
  <li>[GCE] Allow preemptible instances to be created</li>
  <li>Add support for forcing detachment of EBS volumes to EC2 driver</li>
  <li>Fix Public IP not assigned when creating NIC on Azure ARM</li>
  <li>[ONAPP] Add list images support for OnApp driver</li>
  <li>[EC2] Add r4 instance types for AWS</li>
  <li>[EC2] support for AWS eu-west-2 and ca-central-1 regions</li>
  <li>[EC2] Add P2 GPU instance types</li>
  <li>[EC2] Add method to modify snapshot attribute for EC2</li>
  <li>[Linode] Add start, stop instance methods and fix incorrect state TERMINATED to STOPPED</li>
  <li>[EC2] Add ENA support for EC2 compute images</li>
  <li>[Azure ARM] fix typeerror on ex_list_nics</li>
  <li>[GCE] allow delete instances from managed group</li>
</ul>

<h3 id="storage">Storage</h3>

<ul>
  <li>Reintroduce S3 multipart upload support with signature v4</li>
</ul>

<h2 id="changes-apache-libcloud-200rc1">Changes Apache Libcloud 2.0.0rc1</h2>

<h3 id="common-1">Common</h3>

<ul>
  <li>Fix DEBUG mode, also add support for using io.StringIO as the file handle when calling libcloud.enable_debug</li>
  <li>Introduction of the requests package as the mechanism for making HTTP requests for all drivers</li>
  <li>Fix bug where custom port and secure flag would not get propagated to connection class</li>
  <li>Fix bug where custom port would not get propagated to connection</li>
  <li>Fix bug where instantiating a connection from URL and then requesting an action with a leading / would lead to
a malformed URL</li>
</ul>

<h3 id="compute-2">Compute</h3>

<ul>
  <li>Fix a bug in profitbricks driver where listing snapshots would request a malformed URL</li>
  <li>Fix LIBCLOUD-806 bug where vsphere driver cannot be instantiated</li>
  <li>[google compute] Improve performance of list nodes by caching volume information.</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="special-thank-you">Special thank you</h3>

<p>I would like to wish a special thank you to all of our community contributors
for their ongoing support to the project.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==2.0.0rc2
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==2.0.0rc2
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/12/29/libcloud-1-5-0-released.html">Libcloud 1.5.0 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Dec 29, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 1.5.0.</p>

<p>This release brings many new features, improvements, bug-fixes, and drivers.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>[azure] New method for accessing rate cards.</li>
  <li>[openstack] Add new Connection class to support VOMS proxys to keystone
servers.</li>
  <li>[ec2] Added m4 instances to us-gov and brazil, added m4.16xlarge to all.</li>
  <li>Add new CloudScale.ch driver</li>
  <li>[dimensiondata] Added support for 2.4 API, added support for image import,
cloning. Add feature for changing NIC VLANs, add feature for changing NIC
order for a server.</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="special-thank-you">Special thank you</h3>

<p>I would like to wish a special thank you to all of our community contributors
for their ongoing support to the project.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==1.5.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==1.5.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/11/27/libcloud-1-4-0-released.html">Libcloud 1.4.0 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Nov 27, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 1.4.0.</p>

<p>This release brings many new features, improvements, bug-fixes, and drivers.</p>

<h3 id="release-highlights">Release highlights</h3>

<p>The release includes a new Azure ARM driver and an Amazon Application
Load Balancer (ALB) driver.</p>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="special-thank-you">Special thank you</h3>

<p>I would like to wish a special thank you to all of our community contributors
for their ongoing support to the project.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==1.4.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==1.4.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/10/14/libcloud-1-3-0-released.html">Libcloud 1.3.0 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Oct 14, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 1.3.0.</p>

<p>This release brings many new features, improvements, bug-fixes, and drivers.</p>

<h3 id="important-changes">Important changes</h3>

<ul>
  <li>RunAbove driver is now the OVH cloud driver because of changes in the
platform. Users will get a deprecated error message and pointed to the
website for more information.</li>
  <li>Fixed support for SLES/OpenSUSE 12, now checks the default certificate
path (does not impact users using certifi).</li>
  <li>DigitalOcean v1 API has been deprecated in favour of the new 2.0 API.</li>
</ul>

<h3 id="release-highlights">Release highlights</h3>

<h4 id="rancher-driver">Rancher Driver</h4>

<p>Mario Loria contributed a full Rancher driver for our container abstraction
interface. Documentation is available with examples of usage, you can use
the driver to deploy containers, services, stacks or operate and maintain
existing deployments! Thanks Mario.</p>

<figure class="highlight">
  <pre><code class="language-python" data-lang="python"><span class="kn">from</span> <span class="nn">libcloud.container.types</span> <span class="kn">import</span> <span class="n">Provider</span>
<span class="kn">from</span> <span class="nn">libcloud.container.providers</span> <span class="kn">import</span> <span class="n">get_driver</span>
<span class="kn">from</span> <span class="nn">libcloud.container.base</span> <span class="kn">import</span> <span class="n">ContainerImage</span>

<span class="n">driver</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">RANCHER</span><span class="p">)</span>

<span class="n">connection</span> <span class="o">=</span> <span class="n">driver</span><span class="p">(</span><span class="s">"MYRANCHERACCESSKEY"</span><span class="p">,</span> <span class="s">"MYRANCHERSECRETKEY"</span><span class="p">,</span>
                    <span class="n">host</span><span class="o">=</span><span class="s">"17.23.66.4"</span><span class="p">,</span> <span class="n">port</span><span class="o">=</span><span class="mi">443</span><span class="p">)</span>

<span class="n">image</span> <span class="o">=</span> <span class="n">ContainerImage</span><span class="p">(</span><span class="s">"hastebin"</span><span class="p">,</span> <span class="s">"hastebin"</span><span class="p">,</span> <span class="s">"rlister/hastebin"</span><span class="p">,</span> <span class="s">"latest"</span><span class="p">,</span>
                       <span class="n">driver</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>

<span class="n">new_service</span> <span class="o">=</span> <span class="n">connection</span><span class="p">.</span><span class="n">ex_deploy_service</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">"excitingservice"</span><span class="p">,</span> <span class="n">image</span><span class="o">=</span><span class="n">image</span><span class="p">,</span>
                                           <span class="n">environmentid</span><span class="o">=</span><span class="s">"1e2"</span><span class="p">,</span>
                                           <span class="n">environment</span><span class="o">=</span><span class="p">{</span>
                                               <span class="s">"STORAGE_TYPE"</span><span class="p">:</span> <span class="s">"file"</span>
                                           <span class="p">})</span></code></pre>
</figure>

<h4 id="new-api">New API</h4>

<p>As well as the direct <code class="language-plaintext highlighter-rouge">get_driver API</code>, there is now a short-hand API for
users to choose.</p>

<figure class="highlight">
  <pre><code class="language-python" data-lang="python"><span class="kn">import</span> <span class="nn">libcloud</span>

<span class="n">cls</span> <span class="o">=</span> <span class="n">libcloud</span><span class="p">.</span><span class="n">get_driver</span><span class="p">(</span><span class="n">libcloud</span><span class="p">.</span><span class="n">DriverType</span><span class="p">.</span><span class="n">COMPUTE</span><span class="p">,</span> <span class="n">libcloud</span><span class="p">.</span><span class="n">DriverType</span><span class="p">.</span><span class="n">COMPUTE</span><span class="p">.</span><span class="n">RACKSPACE</span><span class="p">)</span></code></pre>
</figure>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="special-thank-you">Special thank you</h3>

<p>I would like to wish a special thank you to all of our community contributors
for their ongoing support to the project.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==1.3.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==1.3.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/09/23/libcloud-1-2-1-released.html">Libcloud 1.2.1 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Sep 23, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 1.2.1.</p>

<p>This release brings many new features, improvements, bug-fixes, and drivers.</p>

<h2 id="release-highlights">Release highlights</h2>

<h3 id="changes-in-apache-libcloud-121">Changes in Apache Libcloud 1.2.1</h3>

<ul>
  <li>Fix issue enabling backups on Dimension Data driver</li>
</ul>

<h3 id="changes-in-apache-libcloud-120">Changes in Apache Libcloud 1.2.0</h3>

<h4 id="general">General</h4>

<ul>
  <li>Fix caching of auth tokens in the Google Compute Engine drivers. Now we make
sure that the file is truncated before writing a new token. Not truncating the
file would cause issues if the new token is shorted then the existing one
which is cached in the file.</li>
</ul>

<h4 id="compute">Compute</h4>

<ul>
  <li>Fix image undeprecation in GCE</li>
  <li>Added Managed Instance Groups in GCE</li>
  <li>Allow undeprecation of an image in GCE</li>
  <li>BUGFIX Values with wildcards failed signature validation in cloudstack</li>
  <li>Added StorageState-Migrating to the cloudstack driver.</li>
  <li>Update copy image logic to match create image in GCE driver.</li>
  <li>Removed HD attribute from the Abiquo compute driver to support the 3.4 API</li>
  <li>Add image and size details to list_nodes response in Dimension Data driver</li>
  <li>Add support for changing VM admin password in VMware driver</li>
  <li>Add Barcelona (Spain) region to the Aurora Compute driver.</li>
  <li>Various improvements in the libvirt driver.</li>
</ul>

<h4 id="load-balancer">Load balancer</h4>

<ul>
  <li>Add support for temporary IAM role credentials (token) to the AWS ELB driver.</li>
</ul>

<h4 id="dns">DNS</h4>

<ul>
  <li>Updated the ‘extra’ parameter in update_record() to be optional in aurora driver</li>
  <li>Support for iterating over records and zones in the Aurora DNS driver</li>
  <li>Add support for DS, PTR, SSFHFP and TLSA record type to the Aurora DNS driver.</li>
</ul>

<h4 id="container">Container</h4>

<ul>
  <li>Add network mode and labels when creating containers within docker driver</li>
</ul>

<h4 id="storage">Storage</h4>

<ul>
  <li>Fix authentication issue in S3/China region, disabled multipart uploads as
not supported by region.</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="special-thank-you">Special thank you</h3>

<p>I would like to wish a special thank you to all of our community contributors
for their ongoing support to the project.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==1.2.1
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==1.2.1
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/07/07/libcloud-1-1-0-released.html">Libcloud 1.1.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jul 07, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 1.1.0.</p>

<p>This is a first release after v1.0.0. It includes various improvements
and bug-fixes.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>Support for automatic SNI (SSL extension) using the hostname
supplied to connect to.</li>
  <li>Various improvements in the libvirt driver</li>
  <li>Various improvements in the DimensionData driver</li>
  <li>Various improvements in the Aliyun driver</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.io/en/v1.1.0/changelog.html#changes-with-apache-libcloud-1-1-0">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==1.1.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==1.1.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v1.1.0/">https://libcloud.readthedocs.org/en/v1.1.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.io/en/v1.1.0/changelog.html#changes-with-apache-libcloud-1-1-0">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/06/22/libcloud-1-0-0-released.html">Libcloud 1.0.0 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Jun 22, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 1.0.0.</p>

<p>This first release in the 1.0 series which means it brings many new
features, improvements, bug-fixes, and drivers. The 1.0 series includes 2 new driver types, <a href="http://libcloud.readthedocs.io/en/latest/container/index.html">container-as-a-service</a> and <a href="http://libcloud.readthedocs.io/en/latest/backup/index.html">backup-as-a-service</a>.</p>

<h3 id="release-highlights">Release highlights</h3>

<p>This includes:</p>

<ul>
  <li>New backup-as-a-service and container-as-a-service driver types</li>
  <li>Deprecated drivers that were no longer available such as Ninefold, IBM SCE <a href="http://libcloud.apache.org/blog/2016/02/16/new-drivers-deprecated-drivers.html">more details</a></li>
  <li>Add support for authenticating against Keystone and OpenStack based clouds
using OpenID Connect tokens.</li>
  <li>GCE nodes can be launched in a subnetwork and support for subnetworks</li>
  <li>Add Image Family support for GCE</li>
  <li>Add new <code class="language-plaintext highlighter-rouge">Perth, Australia</code> and <code class="language-plaintext highlighter-rouge">Manila, Philippines</code> region to the CloudSigma
v2 driver.</li>
  <li>Add new S3 RGW storage driver.</li>
  <li>The Amazon EC2 driver has been changed to use region codes instead of separate drivers for each region.</li>
  <li>Introduce new <code class="language-plaintext highlighter-rouge">list_regions</code> class method on the base driver class</li>
  <li>Support for Dimension Data backup</li>
  <li>Added NSOne, LuaDNS, NearlyFreeSpeech.NET, BuddyNS, DNSPod DNS drivers</li>
  <li>Added Aliyun compute, load balancer and storage drivers</li>
  <li>Added Outscale storage driver</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="special-thank-you">Special thank you</h3>

<p>I would like to wish a special thank you to all of our community contributors for their ongoing support to the project.</p>

<p><a href="https://github.com/Kami">Tomaz Muraus</a>, <a href="https://github.com/pquerna">Paul Querna</a>, 
<a href="https://github.com/jcsalterego">Jerry Chen</a>, <a href="https://github.com/jadunham1">Jeff Dunham</a>, <a href="https://github.com/erjohnso">Eric Johnson</a>,
<a href="https://github.com/jedsmith">Jed Smith</a>, <a href="https://github.com/wrigri">Rick Wright</a>, <a href="https://github.com/novel">Roman Bogorodskiy</a>,
<a href="https://github.com/baldwinmathew">Mathew Baldwin</a>, <a href="https://github.com/davidcrossland">David Crossland</a>, <a href="https://github.com/alex">Alex Gaynor</a>,
<a href="https://github.com/allardhoeve">Allard Hoeve</a>, <a href="https://github.com/runseb">Sebastien Goasguen</a>, <a href="https://github.com/franckcuny">Franck Cuny</a>,
<a href="https://github.com/ktdreyer">Ken Dreyer</a>, <a href="https://github.com/jcastillo2nd">Javier Castillo II</a>, <a href="https://github.com/wido">Wido den Hollander</a>,
<a href="https://github.com/bennettaur">Michael Bennett</a>, <a href="https://github.com/ZuluPro">Anthony Monthe</a>, <a href="https://github.com/zerthimon">Lior Goikhburg</a>,
<a href="https://github.com/encyphered">Geunwoo Shin</a>, <a href="https://github.com/juanfont">Juan Font</a>, <a href="https://github.com/schaubl">“schaubl”</a>,
<a href="https://github.com/mbrukman">Misha Brukman</a>, <a href="https://github.com/jetbird">Oltjano Terpollari</a>, <a href="https://github.com/pzrq">Peter Schmidt</a>,
<a href="https://github.com/mingsheng36">Ming Sheng</a>, <a href="https://github.com/gertjanol">Gertjan Oude Lohuis</a>,
<a href="https://github.com/mgogoulos">Markos Gogoulos</a>, <a href="https://github.com/bernard357">Bernard Paques</a>,
<a href="https://github.com/Phreedom">Evgeny Egorochkin</a>, <a href="https://github.com/gigimon">Oleg</a>, <a href="https://github.com/atsaki">Atsushi Sasaki</a>,
<a href="https://github.com/micafer">Miguel Caballer</a>, <a href="https://github.com/kumarappanc">Kumar</a>, <a href="https://github.com/gmcdonald">Gavin McDonald</a>,
<a href="https://github.com/boul">Roeland Kuipers</a>, <a href="https://github.com/briancurtin">Brian Curtin</a>, <a href="https://github.com/ikusalic">Ivan Kusalic</a>,
<a href="https://github.com/ferewuz">Vanč Levstik</a>, <a href="https://github.com/davidwilson2038">None</a>, <a href="https://github.com/Smotko">Anže Pečar</a>,
<a href="https://github.com/MrBasset">“MrBasset”</a>, <a href="https://github.com/crunkleton">None</a>, <a href="https://github.com/jmunhoz">Javier M. Mellid</a>,
<a href="https://github.com/jimbobhickville">Greg Hill</a>, <a href="https://github.com/Jc2k">None</a>, <a href="https://github.com/sfriesel">Stefan Friesel</a>,
<a href="https://github.com/relaxdiego">Mark Maglana</a>, <a href="https://github.com/aleGpereira">Alejandro Gabriel Pereira</a>,
<a href="https://github.com/kyle-long">Kyle Long</a>, <a href="https://github.com/teemuvesala">Teemu Vesala</a>, <a href="https://github.com/LordShion">Filipe Silva</a>,
<a href="https://github.com/jshridha">Jay</a>, <a href="https://github.com/bernieke">Bernard Kerckenaere</a>, <a href="https://github.com/jobelenus">John Obelenus</a>,
<a href="https://github.com/bsdlp">Jon Chen</a>, <a href="https://github.com/lawrencellui-dd">Larry Lui</a>,</p>

<h3 id="important-breaking-change---amazon-ec2-driver-changes">Important breaking change-  Amazon EC2 driver changes</h3>

<p>The Amazon EC2 API was updated to consolidate the regional-based drivers into a single driver with a region argument in the constructor.</p>

<p>Amazon Instances should now be instantiated using the following syntax:</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="kn">from</span> <span class="nn">libcloud.compute.types</span> <span class="kn">import</span> <span class="n">Provider</span>
<span class="kn">from</span> <span class="nn">libcloud.compute.providers</span> <span class="kn">import</span> <span class="n">get_driver</span>

<span class="n">cls</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">EC2</span><span class="p">)</span>
<span class="n">driver</span> <span class="o">=</span> <span class="n">cls</span><span class="p">(</span><span class="s">'access key'</span><span class="p">,</span> <span class="s">'secret key'</span><span class="p">,</span> <span class="n">region</span><span class="o">=</span><span class="s">'us-east-1'</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>This brings the Amazon API inline with the other drivers, makes it easier to maintain and switch between regions.</p>

<h3 id="bug-fixes">Bug fixes</h3>

<h4 id="general">General</h4>

<ul>
  <li>
    <p>Fix a bug with consuming stdout and stderr in the paramiko SSH client which
would manifest itself under very rare condition when a consumed chunk only
contained a single byte or part of a multi byte UTF-8 character.
[Lakshmi Kannan, Tomaz Muraus]</p>
  </li>
  <li>
    <p>Increase default chunk size from <code class="language-plaintext highlighter-rouge">1024</code> to <code class="language-plaintext highlighter-rouge">4096</code> bytes in the paramiko
SSH client. This results in smaller number of receive calls on the average.
[Tomaz Muraus]</p>
  </li>
  <li>
    <p>Fix to Dimension Data API address for Middle-East and Africa
(GITHUB-700)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>Throw a more user-friendly exception on “No address associated with hostname”.
(GITHUB-711, GITHUB-714, LIBCLOUD-803)
[Tomaz Muraus, Scott Crunkleton]</p>
  </li>
  <li>
    <p>Remove deprecated provider constants with the region in the name and related
driver classes (e.g. <code class="language-plaintext highlighter-rouge">EC2_US_EAST</code>, etc.).</p>

    <p>Those drivers have moved to single provider constant + <code class="language-plaintext highlighter-rouge">region</code> constructor
argument model.
[Tomaz Muraus]</p>
  </li>
</ul>

<h3 id="new-or-deprecated-drivers">New or deprecated drivers</h3>

<h4 id="compute">Compute</h4>

<ul>
  <li>
    <p>Deprecated IBM SCE, HP Helion, OpSource, Ninefold and CloudFrames drivers, removed
driver code and tests.
(GITHUB-701, LIBCLOUD-801)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>Introduced error messages (<code class="language-plaintext highlighter-rouge">libcloud.compute.deprecated</code>) for deprecated drivers
(GITHUB-701, LIBCLOUD-801)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>New Compute drivers- BSNL, Indosat, Med-1, NTT-America, Internet Solutions
(GITHUB-700)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>New driver for Aliyun Elastic Compute Service.
(LIBCLOUD-802, GITHUB-712)
[Sam Song]</p>
  </li>
</ul>

<h4 id="storage">Storage</h4>

<ul>
  <li>
    <p>Added Outscale storage driver
(GITHUB-730)
[Javier M. Mellid]</p>
  </li>
  <li>
    <p>New driver for Aliyun OSS Storage Service.
(LIBCLOUD-802, GITHUB-712)
[Sam Song]</p>
  </li>
</ul>

<h4 id="loadbalancer">Loadbalancer</h4>

<ul>
  <li>New driver for Aliyun SLB Loadbalancer Service.
(LIBCLOUD-802, GITHUB-712)
[Sam Song]</li>
</ul>

<h4 id="dns">DNS</h4>

<ul>
  <li>
    <p>Added NearlyFreeSpeech.net (NSFN) driver
[Ken Drayer]</p>
  </li>
  <li>
    <p>Added Lua DNS driver
[Oltjano Terpollari]</p>
  </li>
  <li>
    <p>Added NSOne driver
[Oltjano Terpollari]</p>
  </li>
</ul>

<h2 id="bug-fixes-1">Bug fixes</h2>

<ul>
  <li>
    <p>Fix a bug in the GoDaddy driver - make sure <code class="language-plaintext highlighter-rouge">host</code> attribute on the
connection class is correctly set to the hostname.
[Tomaz Muraus]</p>
  </li>
  <li>
    <p>Fix handling of <code class="language-plaintext highlighter-rouge">MX</code> records in the Gandi driver.
(GITHUB-718)
[Ryan Lee]</p>
  </li>
</ul>

<h2 id="improvements">Improvements</h2>

<h3 id="compute-1">Compute</h3>

<ul>
  <li>
    <p>Introduce new <code class="language-plaintext highlighter-rouge">list_regions</code> class method on the base driver class. This
method is to be used with provider drivers which support multiple regions and
<code class="language-plaintext highlighter-rouge">region</code> constructor argument. It allows users to enumerate available /
supported regions.
[Tomaz Muraus]</p>
  </li>
  <li>
    <p>[dimension data] added support for VMWare tools VM information inside list_nodes responses
(GITHUB-734)
[Jeff Dunham]</p>
  </li>
  <li>
    <p>[ec2] added ex_encrypted and ex_kms_key_id optional parameters to the create volume method
(GITHUB-729)
[Viktor Ognev]</p>
  </li>
  <li>
    <p>[dimension data] added support for managing host anti-affinity rules, added paging support to
all supported calls and added support for requesting priority ordering when creating ACL rules
(GITHUB-726)
[Jeff Dunham]</p>
  </li>
  <li>
    <p>Addition of Dimension Data Australia federal government region to dimension data
drivers.
(GITHUB-700)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>[openstack] when creating floating IPs, added pool_id as an optional argument
(GITHUB-725)
[marko-p]</p>
  </li>
  <li>
    <p>[google compute] Added setMachineType method to allow for changing sizes of instances
(GITHUB-721)
[Eric Johnson]</p>
  </li>
  <li>
    <p>[google compute] allow bypassing image search in standard project list
(GITHUB-713)
[Max Illfelder]</p>
  </li>
  <li>
    <p>Add support for requesting a MKS token for accessing the remote console in VMware
vCloud driver
(GITHUB-706)
[Juan Font Alonso]</p>
  </li>
  <li>
    <p>Add support in VMware vCloud driver for v5.5 API, with snapshot support
(GITHUB-658)
[Juan Font Alonso]</p>
  </li>
  <li>
    <p>Added support for adding a family to an image on Google Compute Driver
(GITHUB-704)
[Max Illfelder]</p>
  </li>
  <li>
    <p>Fix to set default signature version for AWS Seoul region to v4, removed
non-supported size (hs1.xlarge)
(GITHUB-684)
[Geunwoo Shin]</p>
  </li>
  <li>
    <p>Support filtering by location in list_nodes for dimension data compute driver
fix lack of paging support
(GITHUB-691)
[Jeff Dunham]</p>
  </li>
  <li>
    <p>Support for filtering by IPv4, IPv6, network, network domain, VLAN in Dimension
data driver.
(GITHUB-694)
[Jeff Dunham]</p>
  </li>
  <li>
    <p>Added <code class="language-plaintext highlighter-rouge">Node.created_at</code> which, on supported drivers, contains the datetime the
node was first started.
(GITHUB-698)
[Allard Hoeve] [Rick van de Loo]</p>
  </li>
</ul>

<h3 id="storage-1">Storage</h3>

<ul>
  <li>
    <p>Improvements to Google Auth for Storage and Compute and MIME bug fix
(LIBCLOUD-800, GITHUB-689)
[Scott Crunkleton]</p>
  </li>
  <li>
    <p>Implement <code class="language-plaintext highlighter-rouge">get_container</code>, <code class="language-plaintext highlighter-rouge">get_object</code> and <code class="language-plaintext highlighter-rouge">upload_object_via_stream</code>
methods in the Backblaze B2 storage driver.</p>

    <p>Note: Backblaze API doesn’t upload streaming uploads so when using
<code class="language-plaintext highlighter-rouge">upload_object_via_stream</code> whole file is read and buffered in memory.
(GITHUB-696)
[Jay jshridha]</p>
  </li>
</ul>

<h3 id="backup">Backup</h3>

<ul>
  <li>Dimension Data - added additional testing, fixed bug on client response naming,
added support for adding backup clients to a backup enabled node.
(GITHUB-692, GITHUB-693, GITHUB-695)
[Jeff Dunham]</li>
</ul>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==1.0.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==1.0.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/04/11/libcloud-1-0-0-rc2-released.html">Libcloud 1.0.0-rc2 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Apr 11, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 1.0.0-rc2.</p>

<p>This the second pre-release in the 1.0.0 series which means it brings many new
features, improvements, bug-fixes, and DNS drivers.</p>

<h3 id="release-highlights">Release highlights</h3>

<p>This includes:</p>

<ul>
  <li>Deprecated drivers that were no longer available such as Ninefold, IBM SCE <a href="http://libcloud.apache.org/blog/2016/02/16/new-drivers-deprecated-drivers.html">more details</a></li>
  <li>The Amazon EC2 driver has been changed to use region codes instead of separate drivers for each region.</li>
  <li>Introduce new <code class="language-plaintext highlighter-rouge">list_regions</code> class method on the base driver class</li>
  <li>Support for Dimension Data backup</li>
  <li>Added NSOne, LuaDNS, NearlyFreeSpeech.NET DNS drivers</li>
  <li>Added Aliyun compute, load balancer and storage drivers</li>
  <li>Added Outscale storage driver</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="important-breaking-change---amazon-ec2-driver-changes">Important breaking change-  Amazon EC2 driver changes</h3>

<p>The Amazon EC2 API was updated to consolidate the regional-based drivers into a single driver with a region argument in the constructor.</p>

<p>Amazon Instances should now be instantiated using the following syntax:</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="kn">from</span> <span class="nn">libcloud.compute.types</span> <span class="kn">import</span> <span class="n">Provider</span>
<span class="kn">from</span> <span class="nn">libcloud.compute.providers</span> <span class="kn">import</span> <span class="n">get_driver</span>

<span class="n">cls</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">EC2</span><span class="p">,</span> <span class="n">region</span><span class="o">=</span><span class="s">'us-east-i1'</span><span class="p">)</span>
<span class="n">driver</span> <span class="o">=</span> <span class="n">cls</span><span class="p">(</span><span class="s">'access key'</span><span class="p">,</span> <span class="s">'secret key'</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>This brings the Amazon API inline with the other drivers, makes it easier to maintain and switch between regions.</p>

<h3 id="bug-fixes">Bug fixes</h3>

<h4 id="general">General</h4>

<ul>
  <li>
    <p>Fix a bug with consuming stdout and stderr in the paramiko SSH client which
would manifest itself under very rare condition when a consumed chunk only
contained a single byte or part of a multi byte UTF-8 character.
[Lakshmi Kannan, Tomaz Muraus]</p>
  </li>
  <li>
    <p>Increase default chunk size from <code class="language-plaintext highlighter-rouge">1024</code> to <code class="language-plaintext highlighter-rouge">4096</code> bytes in the paramiko
SSH client. This results in smaller number of receive calls on the average.
[Tomaz Muraus]</p>
  </li>
  <li>
    <p>Fix to Dimension Data API address for Middle-East and Africa
(GITHUB-700)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>Throw a more user-friendly exception on “No address associated with hostname”.
(GITHUB-711, GITHUB-714, LIBCLOUD-803)
[Tomaz Muraus, Scott Crunkleton]</p>
  </li>
  <li>
    <p>Remove deprecated provider constants with the region in the name and related
driver classes (e.g. <code class="language-plaintext highlighter-rouge">EC2_US_EAST</code>, etc.).</p>

    <p>Those drivers have moved to single provider constant + <code class="language-plaintext highlighter-rouge">region</code> constructor
argument model.
[Tomaz Muraus]</p>
  </li>
</ul>

<h3 id="new-or-deprecated-drivers">New or deprecated drivers</h3>

<h4 id="compute">Compute</h4>

<ul>
  <li>
    <p>Deprecated IBM SCE, HP Helion, OpSource, Ninefold and CloudFrames drivers, removed
driver code and tests.
(GITHUB-701, LIBCLOUD-801)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>Introduced error messages (<code class="language-plaintext highlighter-rouge">libcloud.compute.deprecated</code>) for deprecated drivers
(GITHUB-701, LIBCLOUD-801)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>New Compute drivers- BSNL, Indosat, Med-1, NTT-America, Internet Solutions
(GITHUB-700)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>New driver for Aliyun Elastic Compute Service.
(LIBCLOUD-802, GITHUB-712)
[Sam Song]</p>
  </li>
</ul>

<h4 id="storage">Storage</h4>

<ul>
  <li>
    <p>Added Outscale storage driver
(GITHUB-730)
[Javier M. Mellid]</p>
  </li>
  <li>
    <p>New driver for Aliyun OSS Storage Service.
(LIBCLOUD-802, GITHUB-712)
[Sam Song]</p>
  </li>
</ul>

<h4 id="loadbalancer">Loadbalancer</h4>

<ul>
  <li>New driver for Aliyun SLB Loadbalancer Service.
(LIBCLOUD-802, GITHUB-712)
[Sam Song]</li>
</ul>

<h4 id="dns">DNS</h4>

<ul>
  <li>
    <p>Added NearlyFreeSpeech.net (NSFN) driver
[Ken Drayer]</p>
  </li>
  <li>
    <p>Added Lua DNS driver
[Oltjano Terpollari]</p>
  </li>
  <li>
    <p>Added NSOne driver
[Oltjano Terpollari]</p>
  </li>
</ul>

<h2 id="bug-fixes-1">Bug fixes</h2>

<ul>
  <li>
    <p>Fix a bug in the GoDaddy driver - make sure <code class="language-plaintext highlighter-rouge">host</code> attribute on the
connection class is correctly set to the hostname.
[Tomaz Muraus]</p>
  </li>
  <li>
    <p>Fix handling of <code class="language-plaintext highlighter-rouge">MX</code> records in the Gandi driver.
(GITHUB-718)
[Ryan Lee]</p>
  </li>
</ul>

<h2 id="improvements">Improvements</h2>

<h3 id="compute-1">Compute</h3>

<ul>
  <li>
    <p>Introduce new <code class="language-plaintext highlighter-rouge">list_regions</code> class method on the base driver class. This
method is to be used with provider drivers which support multiple regions and
<code class="language-plaintext highlighter-rouge">region</code> constructor argument. It allows users to enumerate available /
supported regions.
[Tomaz Muraus]</p>
  </li>
  <li>
    <p>[dimension data] added support for VMWare tools VM information inside list_nodes responses
(GITHUB-734)
[Jeff Dunham]</p>
  </li>
  <li>
    <p>[ec2] added ex_encrypted and ex_kms_key_id optional parameters to the create volume method
(GITHUB-729)
[Viktor Ognev]</p>
  </li>
  <li>
    <p>[dimension data] added support for managing host anti-affinity rules, added paging support to
all supported calls and added support for requesting priority ordering when creating ACL rules
(GITHUB-726)
[Jeff Dunham]</p>
  </li>
  <li>
    <p>Addition of Dimension Data Australia federal government region to dimension data
drivers.
(GITHUB-700)
[Anthony Shaw]</p>
  </li>
  <li>
    <p>[openstack] when creating floating IPs, added pool_id as an optional argument
(GITHUB-725)
[marko-p]</p>
  </li>
  <li>
    <p>[google compute] Added setMachineType method to allow for changing sizes of instances
(GITHUB-721)
[Eric Johnson]</p>
  </li>
  <li>
    <p>[google compute] allow bypassing image search in standard project list
(GITHUB-713)
[Max Illfelder]</p>
  </li>
  <li>
    <p>Add support for requesting a MKS token for accessing the remote console in VMware
vCloud driver
(GITHUB-706)
[Juan Font Alonso]</p>
  </li>
  <li>
    <p>Add support in VMware vCloud driver for v5.5 API, with snapshot support
(GITHUB-658)
[Juan Font Alonso]</p>
  </li>
  <li>
    <p>Added support for adding a family to an image on Google Compute Driver
(GITHUB-704)
[Max Illfelder]</p>
  </li>
  <li>
    <p>Fix to set default signature version for AWS Seoul region to v4, removed
non-supported size (hs1.xlarge)
(GITHUB-684)
[Geunwoo Shin]</p>
  </li>
  <li>
    <p>Support filtering by location in list_nodes for dimension data compute driver
fix lack of paging support
(GITHUB-691)
[Jeff Dunham]</p>
  </li>
  <li>
    <p>Support for filtering by IPv4, IPv6, network, network domain, VLAN in Dimension
data driver.
(GITHUB-694)
[Jeff Dunham]</p>
  </li>
  <li>
    <p>Added <code class="language-plaintext highlighter-rouge">Node.created_at</code> which, on supported drivers, contains the datetime the
node was first started.
(GITHUB-698)
[Allard Hoeve] [Rick van de Loo]</p>
  </li>
</ul>

<h3 id="storage-1">Storage</h3>

<ul>
  <li>
    <p>Improvements to Google Auth for Storage and Compute and MIME bug fix
(LIBCLOUD-800, GITHUB-689)
[Scott Crunkleton]</p>
  </li>
  <li>
    <p>Implement <code class="language-plaintext highlighter-rouge">get_container</code>, <code class="language-plaintext highlighter-rouge">get_object</code> and <code class="language-plaintext highlighter-rouge">upload_object_via_stream</code>
methods in the Backblaze B2 storage driver.</p>

    <p>Note: Backblaze API doesn’t upload streaming uploads so when using
<code class="language-plaintext highlighter-rouge">upload_object_via_stream</code> whole file is read and buffered in memory.
(GITHUB-696)
[Jay jshridha]</p>
  </li>
</ul>

<h3 id="backup">Backup</h3>

<ul>
  <li>Dimension Data - added additional testing, fixed bug on client response naming,
added support for adding backup clients to a backup enabled node.
(GITHUB-692, GITHUB-693, GITHUB-695)
[Jeff Dunham]</li>
</ul>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==1.0.0-rc2
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==1.0.0-rc2
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</a>.</p>

<p>We would like to thank the following community members for their contribution to this release:</p>

<ul>
  <li>Jeff Dunham</li>
  <li>Max Illfelder</li>
  <li>Ken Dreyer</li>
  <li>Sam Song</li>
  <li>Oltjano Terpollari</li>
  <li>Javier M. Mellid</li>
</ul>


  </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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/04/06/requests-support.html">Experimental support for the requests package</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Apr 06, 2016</span>

  <div class="post-content">
    <h2 id="background">Background</h2>

<p>I’ve just pushed a branch of the latest version of libcloud using the popular <code class="language-plaintext highlighter-rouge">requests</code> package by Kenneth Reitz instead of our home-rolled HTTP client library.</p>

<p>This article is for both users and developers of libcloud. If you want to give feedback, please join the developer mailing list.</p>

<h2 id="why">Why?</h2>

<ul>
  <li>requests is the defacto standard - it would be in the standard library but agreed against to allow it to develop faster https://github.com/kennethreitz/requests/issues/2424</li>
  <li>it works with python 2.6-&gt;3.5</li>
  <li>Our SSL experience has a lot to be desired for Windows users, having to download the CA cert package and setting environment variables just to get SSL working</li>
  <li>Developers can use requests_mock for deeper integration testing</li>
  <li>less code to maintain</li>
  <li>the role of libcloud is for cloud abstraction, we provide no value in writing and maintaining our own HTTP client library</li>
</ul>

<h2 id="benefits-of-requests">Benefits of requests</h2>

<p>There are a number of benefits to having a requests package</p>

<ul>
  <li>The client library code is smaller, leaner and simpler.</li>
  <li>Requests has built in decompression support, we no longer need to support this</li>
  <li>Requests has built in RAW download, upload support, helping with our storage drivers</li>
</ul>

<h2 id="implications-of-the-change">Implications of the change</h2>

<ul>
  <li>There are no longer 2 classes (<code class="language-plaintext highlighter-rouge">LibcloudHTTPSConnection</code> and <code class="language-plaintext highlighter-rouge">LibcloudHTTPConnection</code>) to be provided to each driver, they are now 1 class - <code class="language-plaintext highlighter-rouge">LibcloudConnection</code>. You probably won’t notice this because it is a property of the <code class="language-plaintext highlighter-rouge">Connection</code> class, but
if you are developing or extending functionality then it is implicated.</li>
  <li>Unit tests will look slightly different (see below)</li>
  <li>This change broke 4200 unit tests (out of 6340)! I’ve since fixed them all since they were coupled to the original implementation, but now I don’t know if all of tests are valid.</li>
</ul>

<h2 id="testing-with-requests">Testing with requests</h2>

<p>Unit tests that were written like this:</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="k">class</span> <span class="nc">DigitalOceanTests</span><span class="p">(</span><span class="n">LibcloudTestCase</span><span class="p">):</span>
  		  
      <span class="k">def</span> <span class="nf">setUp</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
          <span class="n">DigitalOceanBaseDriver</span><span class="p">.</span><span class="n">connectionCls</span><span class="p">.</span><span class="n">conn_classes</span> <span class="o">=</span> \	
           <span class="p">(</span><span class="bp">None</span><span class="p">,</span> <span class="n">DigitalOceanMockHttp</span><span class="p">)</span>
          <span class="n">DigitalOceanMockHttp</span><span class="p">.</span><span class="nb">type</span> <span class="o">=</span> <span class="bp">None</span>
          <span class="bp">self</span><span class="p">.</span><span class="n">driver</span> <span class="o">=</span> <span class="n">DigitalOceanBaseDriver</span><span class="p">(</span><span class="o">*</span><span class="n">DIGITALOCEAN_v1_PARAMS</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>Because of the change have been modified to (I updated all of them - so this is just for future reference)</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="k">class</span> <span class="nc">DigitalOceanTests</span><span class="p">(</span><span class="n">LibcloudTestCase</span><span class="p">):</span>
  		  
      <span class="k">def</span> <span class="nf">setUp</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
          <span class="n">DigitalOceanBaseDriver</span><span class="p">.</span><span class="n">connectionCls</span><span class="p">.</span><span class="n">conn_class</span> <span class="o">=</span> <span class="n">DigitalOceanMockHttp</span>
          <span class="n">DigitalOceanMockHttp</span><span class="p">.</span><span class="nb">type</span> <span class="o">=</span> <span class="bp">None</span>
          <span class="bp">self</span><span class="p">.</span><span class="n">driver</span> <span class="o">=</span> <span class="n">DigitalOceanBaseDriver</span><span class="p">(</span><span class="o">*</span><span class="n">DIGITALOCEAN_v1_PARAMS</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<h1 id="check-it-out">Check it out!</h1>

<p>The package is on my personal apache site, you can download it and install it in a virtualenv for testing.</p>

<p><code class="language-plaintext highlighter-rouge">pip install -e http://people.apache.org/~anthonyshaw/libcloud/1.0.0-rc2-requests/apache-libcloud-1.0.0-rc2-requests.zip@feature#egg=apache-libcloud</code></p>

<p>The hashes are my <a href="http://people.apache.org/~anthonyshaw/libcloud/1.0.0-rc2-requests/">apache space</a></p>

<p>Have a look at the <a href="https://github.com/apache/libcloud/pull/728/files">PR and the change set</a> for a list of changes</p>

<h1 id="what-might-break">What might break?</h1>

<p>What I’m really looking for is for users of Libcloud to take 15 minutes, an existing (working) libcloud script, install this package in a virtualenv and just validate
that there are no regression bugs with this change.</p>

<p>I’m particularly sceptical about the storage drivers.</p>

<p>Once we have enough community feedback, we will propose a vote to merge this into trunk for future release.</p>

<h2 id="credit">Credit</h2>

<p>Credit to dz0ny on IRC for contributing some of the requests patch.</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/api.html" rel="tag">API</a>, <a href="/blog/tags/tutorial.html" rel="tag">tutorial</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/02/16/new-drivers-deprecated-drivers.html">New compute drivers and deprecated drivers in 1.0</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Feb 16, 2016</span>

  <div class="post-content">
    <p>With Libcloud 1.0.0 around the corner, it’s time to have a spring clean of the compute drivers. Granted, it’s not spring everywhere -actually
I’m writing from Sydney, Australia where it’s definitely summer.</p>

<p>Looking at the 52 providers in the 0.21.0 release, I have identified 5 providers that are no longer available or open.</p>

<ul>
  <li>CloudFrames</li>
  <li>Looks dead - website doesn’t work, can’t see any references to this online.</li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.compute.drivers.cloudframes</code></li>
  <li>HP Public Cloud (Helion)</li>
  <li><a href="https://tahoe-lafs.org/trac/tahoe-lafs/ticket/2566">Shut down on 31st of January 2016</a></li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.compute.drivers.hpcloud</code></li>
  <li>IBM SmartCloud Enterprise</li>
  <li><a href="http://www.theregister.co.uk/2013/10/31/ibm_to_shutter_smartcloud_enterprise_moves_customers_to_softlayer/">Shut down 2014, customers instructed to move to SoftLayer</a></li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.compute.drivers.ibm_sce</code></li>
  <li>Ninefold</li>
  <li><a href="http://www.itnews.com.au/news/ninefold-to-shut-down-411312">Ninefold shut down in January 2016</a></li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.compute.drivers.ninefold</code></li>
  <li>Opsource</li>
  <li>Dimension Data acquired OpSource in 2012, the Opsource driver is succeeded by the Dimension Data driver.</li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.compute.drivers.opsource</code></li>
</ul>

<h3 id="handling-deprecated-drivers">Handling deprecated drivers</h3>

<p>For 1.0.0, we need a clean and user-friendly way of handling deprecated drivers as well as keeping the repository clean from legacy code.</p>

<p>The most obvious implementation is that calls to <code class="language-plaintext highlighter-rouge">get_driver(Provider.NINEFOLD)</code> as an example will return a user error message saying
this provider is no longer supported with a link to a new article and an alternative solution.</p>

<p>Currently, users trying to instantiate a HPE public cloud driver for example will get a connection error, which is not user friendly.</p>

<h3 id="new-compute-drivers-in-100-pre2">New compute drivers in 1.0.0-pre2</h3>

<p>The upcoming release, so currently available in trunk contains some new compute drivers.</p>

<ul>
  <li><a href="http://libcloud.readthedocs.org/en/latest/compute/drivers/ntta.html">NTT America Public Cloud</a></li>
  <li><a href="http://libcloud.readthedocs.org/en/latest/compute/drivers/internetsolutions.html">Internet Solutions Public Cloud</a></li>
  <li><a href="http://libcloud.readthedocs.org/en/latest/compute/drivers/medone.html">Med-1 Public Cloud</a></li>
  <li><a href="http://libcloud.readthedocs.org/en/latest/compute/drivers/indosat.html">Indosat Cloud</a></li>
  <li><a href="http://libcloud.readthedocs.org/en/latest/compute/drivers/bsnl.html">BSNL IDC Cloud</a></li>
</ul>

<p>Full change log can be found at <a href="https://github.com/apache/libcloud/blob/trunk/CHANGES.rst">here</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/announcement.html" rel="tag">announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/02/05/libcloud-containers-example.html">Using the container abstraction API in 1.0.0-pre1</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Feb 05, 2016</span>

  <div class="post-content">
    <h2 id="background">Background</h2>

<p>Containers are the talk of the town, you can’t escape an event or meetup without someone talking about containers. The lessons we
learnt with compute abstraction are applying widely with containers in 2016. APIs are not consistent between clouds, designs are not
standardised and yet, users are trying to consume multiple services.</p>

<p>We introduced Container-as-a-Service support in <a href="http://libcloud.apache.org/blog/2016/01/26/libcloud-1-0-0-pre1-released.html">1.0.0-pre1</a>, a community pre-release with the intention of sparking feedback from 
the open-source community about the design and the implementation of 4 example drivers :</p>

<ul>
  <li>Docker</li>
  <li>Joyent Triton</li>
  <li>Amazon EC2 Container Service</li>
  <li>Google Kubernetes</li>
</ul>

<p>In this tutorial we’re going to explore how to do this:</p>

<div class="imginline">
  <p><img src="/images/posts/2016-02-05-containers/container_cloud_example.png" class="img-responsive inline" /></p>
  <p class="img-caption">Deploying containers across platforms.</p>
</div>

<p>Pulling images from the Docker hub, deploying to Docker, Kubernetes and Amazon ECS then auditing them with a single query.</p>

<h2 id="getting-started-with-100-pre1">Getting Started with 1.0.0-pre1</h2>

<p>First off, let’s install the new packages, you probably want to do this within a virtualenv if you’re using Apache Libcloud for other projects.</p>

<p>So run these commands at a Linux Shell to create a virtualenv called ‘containers’ and install the pre-release packages into that environment.</p>

<div class="language-bash highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   virtualenv containers
   <span class="nb">cd </span>containers
   <span class="nb">source </span>bin/activate
   pip <span class="nb">install </span>apache-libcloud<span class="o">==</span>1.0.0-pre1
</code></pre>
  </div>
</div>

<p>Now you can start using this package with a test script, let’s create one called containers.py</p>

<div class="language-bash highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="nb">touch </span>containers.py
</code></pre>
  </div>
</div>

<p>Using your favourite text editor, update that file to import the 1.0.0-pre1 libraries and the factory methods for instantiating containers.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="kn">from</span> <span class="nn">libcloud.container.providers</span> <span class="kn">import</span> <span class="n">get_driver</span>
   <span class="kn">from</span> <span class="nn">libcloud.container.types</span> <span class="kn">import</span> <span class="n">Provider</span>
</code></pre>
  </div>
</div>

<p><code class="language-plaintext highlighter-rouge">get_driver</code> is a factory method as with all libcloud APIs, you call this method with the <code class="language-plaintext highlighter-rouge">Provider</code> that you want to instantiate. Our options are:</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">Provider.DOCKER</code> - Standalone Docker API</li>
  <li><code class="language-plaintext highlighter-rouge">Provider.KUBERNETES</code> - Kubernetes Cluster endpoint</li>
  <li><code class="language-plaintext highlighter-rouge">Provider.JOYENT</code> - Joyent Triton Public API</li>
  <li><code class="language-plaintext highlighter-rouge">Provider.ECS</code> - Amazon EC2 Container Service</li>
</ul>

<p>Calling <code class="language-plaintext highlighter-rouge">get_driver</code> will return a reference to the driver class that you requested. You can then instantiate that class into an object using the 
contructor. This is always a set of parameters for setting the host or region, the authentication and any other options.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="n">driver</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">DOCKER</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>Now we can call our driver and get an instance of it called <code class="language-plaintext highlighter-rouge">docker_driver</code> and use that to deploy a container. For Docker you need the pem files on the server,
the host (IP or FQDN) and the port.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="n">docker_driver</span> <span class="o">=</span> <span class="n">driver</span><span class="p">(</span><span class="n">host</span><span class="o">=</span><span class="s">'https://198.61.239.128'</span><span class="p">,</span> <span class="n">port</span><span class="o">=</span><span class="mi">4243</span><span class="p">,</span>
             <span class="n">key_file</span><span class="o">=</span><span class="s">'key.pem'</span><span class="p">,</span> <span class="n">cert_file</span><span class="o">=</span><span class="s">'cert.pem'</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>Docker requires that images are available in the image database before they can be deployed as containers. With Kubernetes and Amazon ECS this step is not required
as when you deploy a container it carries out that download for you.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="n">image</span> <span class="o">=</span> <span class="n">driver</span><span class="p">.</span><span class="n">install_image</span><span class="p">(</span><span class="s">'tomcat:8.0'</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>Now that Docker has the version 8.0 image of Apache Tomcat, you can deploy this as a container called <code class="language-plaintext highlighter-rouge">my_tomcat_container</code>. Tomcat runs on TCP/8080 by default so we 
want to bind that port for our container using an optional parameter <code class="language-plaintext highlighter-rouge">port_bindings</code></p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="n">bindings</span> <span class="o">=</span> <span class="p">{</span> <span class="s">"22/tcp"</span><span class="p">:</span> <span class="p">[{</span> <span class="s">"HostPort"</span><span class="p">:</span> <span class="s">"11022"</span> <span class="p">}]</span> <span class="p">}</span>
   <span class="n">container</span> <span class="o">=</span> <span class="n">driver</span><span class="p">.</span><span class="n">deploy_container</span><span class="p">(</span><span class="s">'my_tomcat_container'</span><span class="p">,</span> <span class="n">image</span><span class="p">,</span> <span class="n">port_bindings</span><span class="o">=</span><span class="n">bindings</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>This will have deployed the container and started it up for you, you can disable the automatic startup by using <code class="language-plaintext highlighter-rouge">start=False</code> as a keyword argument. You can now call upon this container and 
run methods, <code class="language-plaintext highlighter-rouge">restart</code>, <code class="language-plaintext highlighter-rouge">start</code>, <code class="language-plaintext highlighter-rouge">stop</code> and <code class="language-plaintext highlighter-rouge">destroy</code>.</p>

<p>For example, to blow away that test container:</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="n">container</span><span class="p">.</span><span class="n">destroy</span><span class="p">()</span>
</code></pre>
  </div>
</div>

<h2 id="crossing-the-streams-calling-kubernetes-and-amazon-ec2-container-service">Crossing the streams; calling Kubernetes and Amazon EC2 Container Service</h2>

<p>With Docker we saw that we needed to “pull” the image before we deployed it. Kubernetes and Amazon ECS don’t have that requirement, but as a safeguard you can query the Docker Hub API using a 
utility class provided</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="kn">from</span> <span class="nn">libcloud.container.utils.docker</span> <span class="kn">import</span> <span class="n">HubClient</span>
   <span class="n">hub</span> <span class="o">=</span> <span class="n">HubClient</span><span class="p">()</span>
   <span class="n">image</span> <span class="o">=</span> <span class="n">hub</span><span class="p">.</span><span class="n">get_image</span><span class="p">(</span><span class="s">'tomcat'</span><span class="p">,</span> <span class="s">'8.0'</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>Now <code class="language-plaintext highlighter-rouge">image</code> can be used to deploy to any driver instance that you create. Let’s try that against Kubernetes and ECS.</p>

<h3 id="amazon-ecs">Amazon ECS</h3>

<p>Before you run this example, you will need an API key and the permissions for that key to have the <code class="language-plaintext highlighter-rouge">AmazonEC2ContainerServiceFullAccess</code> role. <code class="language-plaintext highlighter-rouge">ap-southeast-2</code> is my nearest region, but you can 
swap this out for any of the Amazon public regions that have the ECS service available.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="n">e_cls</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">ECS</span><span class="p">)</span>
   <span class="n">ecs</span> <span class="o">=</span> <span class="n">e_cls</span><span class="p">(</span><span class="n">access_id</span><span class="o">=</span><span class="s">'SDHFISJDIFJSIDFJ'</span><span class="p">,</span>
               <span class="n">secret</span><span class="o">=</span><span class="s">'THIS_IS)+_MY_SECRET_KEY+I6TVkv68o4H'</span><span class="p">,</span>
               <span class="n">region</span><span class="o">=</span><span class="s">'ap-southeast-2'</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>ECS and Kubernetes both support some form of grouping or clustering for your containers. This is available as <code class="language-plaintext highlighter-rouge">create_cluster</code>, <code class="language-plaintext highlighter-rouge">list_cluster</code>.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>   <span class="n">cluster</span> <span class="o">=</span> <span class="n">ecs</span><span class="p">.</span><span class="n">create_cluster</span><span class="p">(</span><span class="s">'default'</span><span class="p">)</span>
   <span class="n">container</span> <span class="o">=</span> <span class="n">ecs</span><span class="p">.</span><span class="n">deploy_container</span><span class="p">(</span>
            <span class="n">cluster</span><span class="o">=</span><span class="n">cluster</span><span class="p">,</span>
            <span class="n">name</span><span class="o">=</span><span class="s">'hello-world'</span><span class="p">,</span>
            <span class="n">image</span><span class="o">=</span><span class="n">image</span><span class="p">,</span>
            <span class="n">start</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span>
            <span class="n">ex_container_port</span><span class="o">=</span><span class="mi">8080</span><span class="p">,</span> <span class="n">ex_host_port</span><span class="o">=</span><span class="mi">8080</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<p>This will have deployed a task definition in Amazon ECS with a single container inside, with a cluster called ‘main’ and deployed the tomcat:8.0 image from the Docker hub to that region.</p>

<p>Check out the <a href="http://libcloud.readthedocs.org/en/latest/container/drivers/ecs.html">ECS Documentation</a> for more details.</p>

<h3 id="kubernetes">Kubernetes</h3>

<p>Kubernetes authentication is currently only implemented for None (off) and Basic HTTP authentication. Let’s use the <a href="http://kubernetes.io/v1.1/docs/admin/authentication.html">basic HTTP authentication method</a> to connect.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>
<span class="n">k_cls</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">KUBERNETES</span><span class="p">)</span>

<span class="n">kubernetes</span> <span class="o">=</span> <span class="n">k_cls</span><span class="p">(</span><span class="n">key</span><span class="o">=</span><span class="s">'my_username'</span><span class="p">,</span>
                   <span class="n">secret</span><span class="o">=</span><span class="s">'THIS_IS)+_MY_SECRET_KEY+I6TVkv68o4H'</span><span class="p">,</span>
                   <span class="n">host</span><span class="o">=</span><span class="s">'126.32.21.4'</span><span class="p">)</span>
<span class="n">cluster2</span> <span class="o">=</span> <span class="n">kubernetes</span><span class="p">.</span><span class="n">create_cluster</span><span class="p">(</span><span class="s">'default'</span><span class="p">)</span>
<span class="n">container2</span> <span class="o">=</span> <span class="n">kubernetes</span><span class="p">.</span><span class="n">deploy_container</span><span class="p">(</span>
            <span class="n">cluster</span><span class="o">=</span><span class="n">cluster</span><span class="p">,</span>
            <span class="n">name</span><span class="o">=</span><span class="s">'hello-world'</span><span class="p">,</span>
            <span class="n">image</span><span class="o">=</span><span class="n">image</span><span class="p">,</span>
            <span class="n">start</span><span class="o">=</span><span class="bp">False</span><span class="p">)</span>
</code></pre>
  </div>
</div>

<h2 id="wrapping-it-up">Wrapping it up</h2>

<p>Now, let’s wrap that all up by doing a list comprehension across the 3 drivers to get a list of all containers and print their ID’s and Names. Then delete them.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="n">containers</span> <span class="o">=</span> <span class="p">[</span><span class="n">conn</span><span class="p">.</span><span class="n">list_containers</span><span class="p">()</span> <span class="k">for</span> <span class="n">conn</span> <span class="ow">in</span> <span class="p">[</span><span class="n">docker</span><span class="p">,</span> <span class="n">ecs</span><span class="p">,</span> <span class="n">kubernetes</span><span class="p">]]</span>
<span class="k">for</span> <span class="n">container</span> <span class="ow">in</span> <span class="n">containers</span><span class="p">:</span>
    <span class="k">print</span><span class="p">(</span><span class="s">"%s : %s"</span> <span class="o">%</span> <span class="p">(</span><span class="n">container</span><span class="p">.</span><span class="nb">id</span><span class="p">,</span> <span class="n">container</span><span class="p">.</span><span class="n">name</span><span class="p">))</span>
    <span class="n">container</span><span class="p">.</span><span class="n">destroy</span><span class="p">()</span>

</code></pre>
  </div>
</div>

<h3 id="about-the-author">About the Author</h3>

<p>Anthony Shaw is on the PMC for Apache Libcloud, you can follow Anthony on Twitter at <a href="https://twitter.com/anthonypjshaw">@anthonypjshaw</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/containers.html" rel="tag">containers</a>, <a href="/blog/tags/tutorial.html" rel="tag">tutorial</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/01/26/libcloud-1-0-0-pre1-released.html">Libcloud 1.0.0-pre1 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Jan 26, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 1.0.0-pre1.</p>

<p>This is a first pre-release in the 1.0.0 series which means it brings many new
features, improvements, bug-fixes, and DNS drivers.</p>

<h3 id="release-highlights">Release highlights</h3>

<p>A full blog post on the new features in 1.0.0 can be found <a href="http://libcloud.apache.org/blog/2016/01/20/libcloud-1.0-pre1.html">here</a></p>

<p>This includes:</p>

<ul>
  <li>Introduction of Container-as-a-Service API drivers for <a href="http://libcloud.readthedocs.org/en/latest/container/drivers/kubernetes.html">Kubernetes</a>, <a href="http://libcloud.readthedocs.org/en/latest/container/drivers/docker.html">Docker</a>, <a href="http://libcloud.readthedocs.org/en/latest/container/drivers/ecs.html">Amazon ECS</a> and <a href="http://libcloud.readthedocs.org/en/latest/container/drivers/joyent.html">Joyent Triton</a></li>
  <li>Introduction of Backup-as-a-Service API</li>
  <li>Addition of South Korea region for Amazon EC2</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==1.0.0-pre1
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==1.0.0-pre1
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/01/20/libcloud-1.0-pre1.html">Libcloud 1.0-pre1 open for feedback</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Jan 20, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce that version 1.0-pre1 vote thread is open and the release is ready for community feedback.</p>

<p>1.0-pre1 marks the first pre-release of the 1.0 major release. Some years ago, Tomaz Muraus spoke on the podcast <a href="https://twit.tv/shows/floss-weekly/episodes/181">FLOSS weekly</a>.
Tomaz spoke about how much of a huge challenge porting the project to Python 3.x would be(!) as well as the 1.0 milestone.</p>

<p>It is worth listening to the podcast to see how far things have come, we now average 2 pull-requests a day and have 156 contributors.</p>

<p>As the project has matured over the last 5 years one of the most remarkable changes has been the adoption from the community and 
continued support from our contributors adding new drivers, patching strange API issues and keeping the project alive.</p>

<p>Anthony Shaw will be speaking on the FLOSS weekly podcast on February 2nd and discussing our community and the project, so 
please tune in.</p>

<p>The Cloud market as I’m sure you’re all aware of is thriving, the purpose of Libcloud was originally:</p>

<ul>
  <li>To help prevent lock-in to a particular vendor</li>
  <li>To abstract the complexity of vendor APIs</li>
  <li>To give a simple way for deploying to and managing multiple cloud vendors</li>
</ul>

<p>Since that we have had (at the last count) 2,118,539 downloads. The project continues to grow in popularity with each new release.</p>

<p>So with the 1.0 major release we would like to announce 2 new driver types, containers and backup.</p>

<h2 id="history-of-our-drivers">History of our drivers</h2>

<p>The compute (IaaS) API is what libcloud is best known for but there is a range of drivers available for many other capabilities.</p>

<p>There is a presentation on the value of using Libcloud to avoid lock in <a href="http://www.slideshare.net/AnthonyShaw5/apache-libcloud-keeping-up-with-the-cloud-market-in-2016">on SlideShare</a></p>

<p>This is a history of the different driver types in the libcloud project.</p>

<ul>
  <li>Compute (v0.1.0)</li>
  <li>Support for nodes, node images, locations, states</li>
  <li>52 providers including every major cloud provider in the market. Plus local services like Vmware, OpenStack, libvirt</li>
  <li>DNS (v0.6.0)</li>
  <li>Support for zones, records, recordtypes</li>
  <li>19 providers including CloudFlare, DigitalOcean, DNSimple, GoDaddy, Google DNS, Linode, Rackspace, Amazon R53, Zerigo</li>
  <li>Object Storage (v0.5.0)</li>
  <li>Support for containers and objects</li>
  <li>11 providers including Amazon S3, Azure Blobs, Google storage, CloudFiles, OpenStack Swift</li>
  <li>Load Balancer (v0.5.0)</li>
  <li>Support for nodes, balancers, listeners and algorithms</li>
  <li>11 providers including CloudStack, Dimension Data, Amazon ELB, Google GCE LB, SoftLayer LB</li>
  <li>Backup (v0.20.0)</li>
  <li>Support for backup targets, recovery points and jobs</li>
  <li>3 providers, Dimension Data, Amazon EBS snaps, Google snaps</li>
</ul>

<h2 id="introducing-backup-drivers">Introducing Backup Drivers</h2>

<p>With 1.0-pre1 we have introduced a new driver type for backup, <code class="language-plaintext highlighter-rouge">libcloud.backup</code></p>

<p>Backup API allows you to manage Backup as A Service and services such as EBS Snaps,
GCE volume snap and dimension data backup.</p>

<h3 id="terminology">Terminology</h3>

<ul>
  <li><code class="language-plaintext highlighter-rouge">libcloud.backup.base.BackupTarget</code> - Represents a backup target, like a Virtual Machine, a folder or a database.</li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.backup.base.BackupTargetRecoveryPoint</code> - Represents a copy of the data in the target, a recovery point can be
recovered to a backup target. An inplace restore is where you recover to the same target and an out-of-place restore is where you
recover to another target.</li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.backup.base.BackupTargetJob</code> - Represents a backup job running on backup target.</li>
</ul>

<h2 id="introducing-container-as-a-service-drivers">Introducing Container-as-a-Service Drivers</h2>

<p>The API is for Container-as-a-Service providers, these new types of cloud services offer container management and hosting as a service.
The new services are already providing proprietary APIs, giving the need for a tool like Libcloud if you want to provision to any cloud provider.</p>

<p>Google, Amazon and Joyent have all announced Container cloud services and Microsoft have launched a beta service also, so we are getting on the front foot with an
abstraction API for people wishing to gain similar benefits to the compute, load balancer and storage APIs.</p>

<p><a href="http://www.slideshare.net/AnthonyShaw5/introducing-container-asaservice-support-to-apache-libcloud">A presentation on this topic is available on SlideShare.</a></p>

<p><strong>Isn’t docker a standard?</strong>
Well, yes and no.</p>

<p>Docker has been the main technology adopted by these providers as the host system for the containers and also as the specification of the containers themselves.
But, Docker is not a provisioning system, it is a virtualization host. Also there are alternatives, like CoreOS Rkt.</p>

<h3 id="container-api-design">Container API design</h3>

<p>Container-as-a-Service providers will implement the <code class="language-plaintext highlighter-rouge">ContainerDriver</code> class to provide functionality for :</p>

<ul>
  <li>Listing deployed containers</li>
  <li>Starting, stopping and restarting containers (where supported)</li>
  <li>Destroying containers</li>
  <li>Creating/deploying containers</li>
  <li>Listing container images</li>
  <li>Installing container images (pulling an image from a local copy or remote repository)</li>
</ul>

<h3 id="simple-container-support">Simple Container Support</h3>

<ul>
  <li><code class="language-plaintext highlighter-rouge">libcloud.container.base.ContainerImage</code> - Represents an image that can be deployed, like an application or an operating system</li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.container.base.Container</code> - Represents a deployed container image running on a container host</li>
</ul>

<h3 id="cluster-suppport">Cluster Suppport</h3>

<p>Cluster support extends on the basic driver functions, but where drivers implement the class-level attribute <code class="language-plaintext highlighter-rouge">supports_clusters</code> as True
clusters may be listed, created and destroyed. When containers are deployed, the target cluster can be specified.</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">libcloud.container.base.ContainerCluster</code> - Represents a deployed container image running on a container host</li>
  <li><code class="language-plaintext highlighter-rouge">libcloud.container.base.ClusterLocation</code> - Represents a location for clusters to be deployed</li>
</ul>

<h3 id="using-the-container-drivers">Using the container drivers</h3>

<p>The container drivers have been designed around similar principles to the compute driver. It is simple to use and a flat class design.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="kn">from</span> <span class="nn">libcloud.container.providers</span> <span class="kn">import</span> <span class="n">get_driver</span>
<span class="kn">from</span> <span class="nn">libcloud.container.types</span> <span class="kn">import</span> <span class="n">Provider</span>

<span class="n">Cls</span> <span class="o">=</span> <span class="n">get_driver</span><span class="p">(</span><span class="n">Provider</span><span class="p">.</span><span class="n">DOCKER</span><span class="p">)</span>
<span class="n">driver</span> <span class="o">=</span> <span class="n">Cls</span><span class="p">(</span><span class="s">'user'</span><span class="p">,</span> <span class="s">'api key'</span><span class="p">)</span>

<span class="n">image</span> <span class="o">=</span> <span class="n">driver</span><span class="p">.</span><span class="n">install_image</span><span class="p">(</span><span class="s">'tomcat:8.0'</span><span class="p">)</span>
<span class="n">container</span> <span class="o">=</span> <span class="n">driver</span><span class="p">.</span><span class="n">deploy_container</span><span class="p">(</span><span class="s">'tomcat'</span><span class="p">,</span> <span class="n">image</span><span class="p">)</span>

<span class="n">container</span><span class="p">.</span><span class="n">restart</span><span class="p">()</span>
</code></pre>
  </div>
</div>

<h3 id="container-registries">Container Registries</h3>

<p>The Docker Registry API is used by services like Amazon ECR, the Docker Hub website and by anyone hosting their own Docker registry.
It doesn’t belong to a particular driver, so is a utility class. 
Some providers, like Amazon ECR have a factory method to provide a registry client
Images from docker registry can be sent to the deploy_container method for any driver.</p>

<div class="language-python highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code><span class="kn">from</span> <span class="nn">libcloud.container.utils.docker</span> <span class="kn">import</span> <span class="n">HubClient</span> 
<span class="n">hub</span> <span class="o">=</span> <span class="n">HubClient</span><span class="p">()</span> 
<span class="n">image</span> <span class="o">=</span> <span class="n">hub</span><span class="p">.</span><span class="n">get_image</span><span class="p">(</span><span class="s">'ubuntu'</span><span class="p">,</span> <span class="s">'latest'</span><span class="p">)</span> 
</code></pre>
  </div>
</div>

<p>When other container registry services are made available these can be provided in a similar context.</p>

<h3 id="prototype-drivers-in-libcloudcontainer">Prototype drivers in libcloud.container</h3>

<p>Drivers have been provided to show example implementations of the API, these drivers are <strong>experimental</strong> and need to go through more thorough community testing
before they are ready for a stable release.</p>

<ul>
  <li><a href="http://libcloud.readthedocs.org/en/latest/container/drivers/docker.html">Docker</a></li>
  <li><a href="http://libcloud.readthedocs.org/en/latest/container/drivers/joyent.html">Joyent Triton</a></li>
  <li><a href="http://libcloud.readthedocs.org/en/latest/container/drivers/kubernetes.html">Google Kubernetes</a></li>
  <li><a href="http://libcloud.readthedocs.org/en/latest/container/drivers/ecs.html">Amazon Elastic Container Service (as well as Amazon Container Registry Service)</a></li>
</ul>

<p>The driver with the most contentious implementation is Kubernetes. We would like users of the Amazon ECS, Google Containers and Kubernetes project to provide feedback
on how they would like to map clusters, pods, namespaces to the low level concepts in the driver.</p>

<h1 id="providing-feedback">Providing feedback</h1>

<p>The <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201601.mbox/%3CCAOZ4b6sJM8ofMinGJCpfJEq7BYcAbfJBVCE7cfPniESqkEpkPQ%40mail.gmail.com%3E">voting thread</a> is open, please use this as your opportunity to give feedback.</p>

<h1 id="thanks">Thanks</h1>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/announcement.html" rel="tag">announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/01/19/libcloud-0-20-1-released.html">Libcloud 0.20.1 released</a></h2>
  
  <span class="post-date-author">By Eric Johnson on Jan 19, 2016</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.20.1.</p>

<p>This is a bug-fix release in the 0.20 series.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>Allow for old and new style service accounts for GCE driver</li>
  <li>Fix syntax error with DimensionDataStatus object</li>
  <li>Fix bug in public IP addition command for DimensionData driver</li>
  <li>Fix error with proxy_url with vCloud Compute driver.</li>
  <li>Fix with hasattr for Rackspace DNS driver.</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==0.20.1
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==0.20.1
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2016/01/14/notice-for-linode-users.html">Notice for Linode users</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 14, 2016</span>

  <div class="post-content">
    <p>This is an announcement for users of the Linode driver for Libcloud who might
have started experiencing issues recently.</p>

<h2 id="background">Background</h2>

<p>A couple of Libcloud users have reported that they have recently started
experiencing issues when talking to the Linode API using Libcloud. They have
received messages similar to the one shown below.</p>

<pre>
socket.error: [Errno 104] Connection reset by peer
</pre>

<p>It turns out that the issue is related to the used SSL / TLS version. For
compatibility and security reasons (Libcloud also supports older Python
versions), Libcloud uses TLS v1.0 by default.</p>

<p>Linode recently dropped support for TLS v1.0 and it now only support TLS &gt;=
v1.1. This means Libcloud won’t work out of the box anymore.</p>

<h2 id="solution">Solution</h2>

<p>If you are experiencing this issue, you should update your code to use TLS v1.2
or TLS v1.1 as shown below.</p>

<div class="language-plaintext highlighter-rouge">
  <div class="highlight">
    <pre class="highlight"><code>import ssl

import libcloud.security
libcloud.security.SSL_VERSION = ssl.PROTOCOL_TLSv1_1
# or even better if your system and Python version supports TLS v1.2
libcloud.security.SSL_VERSION = ssl.PROTOCOL_TLSv1_2

# Instantiate and work with the Linode driver here...
</code></pre>
  </div>
</div>

<p>Keep in mind that for this to work you need to have a recent version of OpenSSL
installed on your system and you need to use Python &gt;= 3.4 or Python 2.7.9.</p>

<p>For more details please see recently updated <a href="https://libcloud.readthedocs.org/en/latest/other/ssl-certificate-validation.html#changing-used-ssl-tls-version">documentation</a>. If you are
still experiencing issues or have any questions, please feel free to reach
us via the mailing list or IRC.</p>

<p>Note: Even if you are not experiencing any issues, it’s generally a good idea
to use the highest version of TLS supported by your system and the provider you
use.</p>

<h2 id="quick-note-on-sslprotocol_sslv23">Quick note on ssl.PROTOCOL_SSLv23</h2>

<p>Python uses <code class="language-plaintext highlighter-rouge">ssl.PROTOCOL_SSLv23</code> constant by default. When this constant is
used, it will let client known to pick the highest protocol version which both
the client and server support (it will be selecting between SSL v3.0, TLS v1.0,
TLS v1.1 and TLS v1.2).</p>

<p>We use <code class="language-plaintext highlighter-rouge">ssl.PROTOCOL_TLSv1</code> instead of <code class="language-plaintext highlighter-rouge">ssl.PROTOCOL_SSLv23</code> for security
and compatibility reasons. SSL v3.0 is considered broken and unsafe and using
<code class="language-plaintext highlighter-rouge">ssl.PROTOCOL_SSLv23</code> can result in an increased risk for a downgrade attack.</p>

<h3 id="thanks">Thanks</h3>

<p>Special thanks to Jacob Riley, Steve V, Heath Naylor and everyone from
<a href="https://issues.apache.org/jira/browse/LIBCLOUD-791">LIBCLOUD-791</a> who helped debug and track down the root cause of this issue.</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/linode.html" rel="tag">linode</a>, <a href="/blog/tags/announcement.html" rel="tag">announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2015/12/15/libcloud-0-20-0-released.html">Libcloud 0.20.0 released</a></h2>
  
  <span class="post-date-author">By Anthony Shaw on Dec 15, 2015</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.20.0.</p>

<p>This is a first release in the 0.20 series which means it brings many new
features, improvements, bug-fixes, and DNS drivers.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>New DNS driver for <a href="http://libcloud.readthedocs.org/en/latest/dns/drivers/godaddy.html">GoDaddy</a></li>
  <li>New DNS driver for <a href="https://www.cloudflare.com/dns/">CloudFlare DNS</a></li>
  <li>Many more improvements and API v2.1 support for the <a href="http://cloud.dimensiondata.com/am/en/">Dimension Data compute driver</a></li>
  <li>Support for adding and configuring PTR (reverse DNS) record in RackSpace DNS driver</li>
  <li>Support for preemptable instances in Google Compute driver</li>
  <li>Add new eu-west-2 &amp; us-east-2 regions to the OUTSCALE_INC &amp; OUTSCALE_SAS drivers</li>
  <li>Added C4, M4 instance types in Amazon EC2 driver</li>
  <li>Add support for multiple regions in Aurora compute driver</li>
  <li>GoogleStorageDriver can now use either our S3 authentication or other Google Cloud Platform OAuth2 authentication methods.</li>
  <li>Removed DreamHosts Compute Driver, DreamHosts users will now use the OpenStack Node driver since DreamHosts are OpenStack API compliant</li>
  <li>and much more!</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-20-0">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==0.20.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==0.20.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-20-0">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2015/11/18/anthony-shaw-joins-our-team.html">Anthony Shaw (anthonyshaw) joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 18, 2015</span>

  <div class="post-content">
    <p>Please help us extend a warm welcome to our newest team member <a href="https://github.com/tonybaloney">Anthony
Shaw</a>!</p>

<p>The Project Management Committee (PMC) for Apache Libcloud has invited Anthony
Shaw to join us as a committer and a PMC member and we are pleased to announce
that he has accepted.</p>

<p>Anthony has joined the community fairly recently, but he has already made a lot
of <a href="https://github.com/apache/libcloud/pulls?q=is%3Apr+author%3Atonybaloney+is%3Aclosed">substantial contributions</a>. Those contributions range from new Dimension
Data drivers and various related improvements to a proposal for a new <a href="https://github.com/apache/libcloud/pull/629">backup
API</a> for Backup as a Service products and projects.</p>

<p>While we are talking about the new backup API - we would like to encourage
everyone who is either a service provider offering Backup as a Service product
or a person interested in using this API to join us and <a href="https://github.com/apache/libcloud/pull/629">participate in the
discussion</a>. The more feedback we get, the better and more widely applicable
we can make this new API.</p>

<p>For anyone who would like to know more about Anthony here is his short bio:</p>

<blockquote>
  <p>Anthony Shaw works for the global system integrator Dimension Data as Head of
Innovation. Anthony has been working in the hosting/service provider industry
for the last 10 years for MSPs within Europe, North America and Australia in
various Product Management and Product Development roles. Anthony is an
open-source advocate and has been promoting the Libcloud project internally to
Dimension Data for the last 9 months as well as maintaining its driver.</p>
</blockquote>

<p>And in his own words:</p>

<blockquote>
  <p>I think we will continue to see consolidation in IaaS providers over the next
12 months, so likelihood is the number of drivers will reduce, but the
importance of being cloud agnostic to people is becoming more apparent as some
are already being burnt by integrations into APIs that companies like Dell and
Ninefold have pulled the plug on. Libcloud is a key project for developers not
wanting to lock themselves too heavily to a vendor. I would also like to see
expansion of additional services like backup, load balancing and containers so
that users can still take advantages of these features through our driver.</p>
</blockquote>

<p>We are happy to have him in our team and we are looking forward to his future
participation and contributions.</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/new-committer.html" rel="tag">new committer</a>, <a href="/blog/tags/new-pmc-member.html" rel="tag">new pmc member</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2015/10/30/libcloud-0-19-0-released.html">Libcloud 0.19.0 released</a></h2>
  
  <span class="post-date-author">By Eric Johnson on Oct 30, 2015</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.19.0.</p>

<p>This is a first release in the 0.19 series which means it brings many new
features, improvements, bug-fixes, and DNS drivers.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>New load balancer driver for <a href="http://cloud.dimensiondata.com/am/en/">Dimension Data</a></li>
  <li>New DNS driver for <a href="https://www.pcextreme.com/aurora/dns">AuroraDNS</a></li>
  <li>New DNS driver for <a href="http://www.worldwidedns.net/home.asp">WorldWideDNS</a></li>
  <li>New DNS driver for <a href="https://dnsimple.com/">DNSimple</a></li>
  <li>New DNS driver for <a href="https://pointhq.com/">PointDNS</a></li>
  <li>New DNS driver for <a href="https://www.vultr.com/">Vult DNS</a></li>
  <li>New DNS driver for <a href="http://www.liquidweb.com/">Liquidweb DNS</a></li>
  <li>New DNS driver for <a href="http://zonomi.com/">Zonomi DNS</a></li>
  <li>New DNS driver for <a href="https://durabledns.com/">Durable DNS</a></li>
  <li>Added volume management methods and more to <a href="https://www.runabove.com/index.xml">RunAbove compute service</a></li>
  <li>Added new South America East region to <a href="https://aws.amazon.com/s3/">S3 storage driver</a></li>
  <li>Many more improvements and API v2.0 added to the <a href="http://cloud.dimensiondata.com/am/en/services/public-cloud/cloud-networks">Dimension Data compute driver</a></li>
  <li>New API v1 support for <a href="https://cloud.google.com/dns/">Google Cloud DNS</a></li>
  <li>Many improvements in the HostVirtual compute driver</li>
  <li>and much more!</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-19-0">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==0.19.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==0.19.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v0.19.0/">https://libcloud.readthedocs.org/en/v0.19.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-19-0">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2015/10/05/libcloud-is-participating-in-hacktoberfest.html">Libcloud is participating in Hacktoberfest</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Oct 05, 2015</span>

  <div class="post-content">
    <p>Github and DigitalOcean are organizing <a href="https://hacktoberfest.digitalocean.com/">Hacktoberfest</a> again this year.</p>

<p>Hacktoberfest is a month-long celebration of open source software where people
are encouraged to contribute to different open source projects. Each user who
submits four pull requests to any Github hosted open source project of their
choice will receive a free t-shirt.</p>

<div class="imginline">
  <p><img src="/images/posts/2015-10-05-libcloud-is-participating-in-hacktoberfest/hacktoberfest-tshirt.png" class="img-responsive inline" /></p>
  <p class="img-caption">Hacktoberfest 2015 t-shirt.</p>
</div>

<p>This year we are also happy to announce that we have been selected as one of
the highlighted Python projects which users are invited to check, play with it
and contribute to.</p>

<p>We think this is a great opportunity for both, long time users and contributors,
but especially people who are new to open source to learn how open source works
and participate.</p>

<p>Having said that, we would like to invite anyone who is interested to participate
and contribute to our project. You can find more information on contributing to
Libcloud in our <a href="https://libcloud.readthedocs.org/en/latest/development.html#contributing">contribution guide</a>.</p>

<p>For more information about the Hacktoberfest project itself and information on
how to sign up, please visit the <a href="https://hacktoberfest.digitalocean.com/">official website</a> and announcement blog post
from <a href="https://github.com/blog/2067-hacktoberfest-contribute-to-open-source-in-october">Github</a> and <a href="https://www.digitalocean.com/company/blog/hacktoberfest-is-back/">DigitalOcean</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/hacktoberfest.html" rel="tag">hacktoberfest</a>, <a href="/blog/tags/github.html" rel="tag">github</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2015/08/13/libcloud-0-18-0-released.html">Libcloud 0.18.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Aug 13, 2015</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.18.0.</p>

<p>This is a first release in the 0.18 series which means it brings many new
features, improvements and bug-fixes.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>New compute driver for <a href="https://azure.microsoft.com/en-us/services/virtual-machines/">Microsoft Azure Virtual Machines service</a></li>
  <li>New compute driver for <a href="https://www.runabove.com/index.xml">RunAbove compute service</a></li>
  <li>New compute driver for <a href="https://www.cloudwatt.com/en/">Cloudwatt compute service</a></li>
  <li>New compute driver for <a href="https://www.packet.net/">Packet.net</a></li>
  <li>New compute driver for <a href="https://onapp.com/platform/onapp-cloud">OnApp Cloud service</a></li>
  <li>New compute driver for <a href="http://cloud.dimensiondata.com/am/en/">Dimension Data compute service</a></li>
  <li>New storage driver for <a href="https://www.pcextreme.nl/en/aurora/objects">AuroraObjects service</a></li>
  <li>New load balancer driver for <a href="https://www.softlayer.com/load-balancing">Softlayer loadbalancing service</a></li>
  <li>New DNS driver for <a href="https://www.digitalocean.com/">DigitalOcean DNS service</a></li>
  <li>Support for DigitalOcean API v2 which is not used by default.</li>
  <li>Support for AWS Signature version 4 and new AWS Frankfurt, Germany region</li>
  <li>Support for retrying failed HTTP requests (disabled by default, to enable it, 
set <code class="language-plaintext highlighter-rouge">LIBCLOUD_RETRY_FAILED_HTTP_REQUESTS</code> environment variable to True)</li>
  <li>Many improvements in the HostVirtual compute driver</li>
  <li>and much more!</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-18-0">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==0.18.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==0.18.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v0.18.0/">https://libcloud.readthedocs.org/en/v0.18.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-18-0">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2015/03/17/allard-hoeve-joins-our-team.html">Allard Hoeve (allard) joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Mar 17, 2015</span>

  <div class="post-content">
    <p>Please help us extend a warm welcome to our newest team member <a href="https://github.com/allardhoeve">Allard
Hoeve</a>!</p>

<p>The Project Management Committee (PMC) for Apache Libcloud has asked Allard
Hoeve to join us as a committer and we are pleased to announce that he has
accepted.</p>

<p>Allard has joined the community just recently, but he has already contributed
some high quality changes and proposals.</p>

<p>We are happy to have him on our team and we are looking forward to his future
contributions.</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/new-committer.html" rel="tag">new committer</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2015/02/18/libcloud-0-17-0-released.html">Libcloud 0.17.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Feb 18, 2015</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.17.0.</p>

<p>This is a first release in the 0.17 series which means it brings many
new features, improvements and bug-fixes.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>New driver for <a href="http://sldn.softlayer.com/reference/services/SoftLayer_Dns_Domain/">Softlayer DNS service</a></li>
  <li>New driver for <a href="https://cloud.google.com/compute/docs/load-balancing/">Google Compute Engine load balancing service</a></li>
  <li>Many improvements and new features in the Google Compute Engine Driver</li>
  <li>Support for new <code class="language-plaintext highlighter-rouge">us-east-2</code> and <code class="language-plaintext highlighter-rouge">us-east-3</code> region in the <a href="https://www.joyent.com/public-cloud">Joyent</a>
compute driver</li>
  <li>Additional functionality in the CloudStack compute driver</li>
  <li>Support for <a href="https://www.cloudsigma.com/2014/08/20/cloudsigma-expands-public-cloud-footprint-with-drfortress-in-hawaii/">new regions</a> in the CloudSigma compute driver</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-17-0">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==0.17.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==0.17.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v0.17.0/">https://libcloud.readthedocs.org/en/v0.17.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-17-0">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/12/04/eric-johnson-joins-our-team.html">Eric Johnson (erjohnso) joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 04, 2014</span>

  <div class="post-content">
    <p>Please help us extend a warm welcome to our newest team member Eric Johnson!</p>

<p>The Project Management Committee (PMC) for Apache Libcloud has asked Eric
Johnson to join us as a committer and a PMC member and we are pleased to
announce that he has accepted.</p>

<p>Eric has been involved in the Libcloud community for a while now. He has made
many substantial contributions to the Google Compute Engine drivers. On top of
that, he also contributed to other projects which utilize Libcloud.</p>

<p>We are happy to have him on our team and we are looking forward to even better
and more complete Google Compute Engine drivers.</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/new-committer.html" rel="tag">new committer</a>, <a href="/blog/tags/new-pmc-member.html" rel="tag">new pmc member</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/11/12/libcloud-0-16-0-released.html">Libcloud 0.16.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 12, 2014</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.16.0!</p>

<p>This is a first release in the 0.16 series which means it brings many
new features, improvements and bug-fixes.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>Support for OpenStack Identity API v3.0. For more information and
examples, see the following blog post - <a href="http://www.tomaz.me/2014/08/23/libcloud-now-supports-openstack-identity-keystone-api-v3.html">Libcloud now supports OpenStack
Identity (Keystone) API v3</a>.</li>
  <li>Support for HTTP proxy for outgoing HTTP requests. For information on how
to use this new feature, please refer to the <a href="https://libcloud.readthedocs.org/en/latest/other/using-http-proxy.html">Using an HTTP proxy</a> section
in the documentation.</li>
  <li>New driver for <a href="http://www.vmware.com/products/vsphere/">VMware vSphere</a> based clouds. For documentation, please see
<a href="https://libcloud.readthedocs.org/en/latest/compute/drivers/vsphere.html">this</a> page.</li>
  <li>Support for <a href="https://aws.amazon.com/govcloud-us/">Amazon GovCloud</a>.</li>
  <li>New driver for the <a href="https://www.profitbricks.com/">ProfitBricks</a> provider.</li>
  <li>Support for authentication with the internal metadata service in the
Google Compute Engine driver. For more information, please refer to the
<a href="https://libcloud.readthedocs.org/en/latest/compute/drivers/gce.html#internal-authentication">Internal Authentication</a> section in the documentation.</li>
  <li>Easier debugging with <code class="language-plaintext highlighter-rouge">LIBCLOUD_DEBUG</code> by pretty-formatting JSON and XML
responses. For information on how to use this feature, see <a href="https://libcloud.readthedocs.org/en/latest/troubleshooting.html#example-2-making-json-xml-response-human-friendly">Making JSON / XML
response human friendly</a> example in the documentation.</li>
  <li>and more</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-16-0">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==0.16.0
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==0.16.0
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-16-0">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-16-0</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v0.16.0/">https://libcloud.readthedocs.org/en/v0.16.0/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-16-0">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/07/10/libcloud-0-15-1-released.html">Libcloud 0.15.1 released</a></h2>
  
  <span class="post-date-author">By Sebastien Goasguen on Jul 10, 2014</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.15.1!</p>

<p>This release includes some bug-fixes and improvements.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>Improvements in the EC2 driver</li>
  <li>Improvements in the CloudStack driver</li>
  <li>Improvements in the Openstack driver</li>
  <li>Fixes a possible race condition in the <code class="language-plaintext highlighter-rouge">deploy_node</code> method</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en//latest/changelog.html#changes-with-apache-libcloud-0-15-1">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==0.15.1
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==0.15.1
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-15-1">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-15-1</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v0.15.1/">https://libcloud.readthedocs.org/en/v0.15.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en//latest/changelog.html#changes-with-apache-libcloud-0-15-1">CHANGES file</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201407.mbox/%3c82E964C2-22F0-4D08-80AA-F3C8EC124B70@gmail.com%3e">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/07/07/libcloud-5th-birthday-celebration-during-europython-week-in-berlin.html">Libcloud's 5th birthday celebration during EuroPython week in Berlin</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jul 07, 2014</span>

  <div class="post-content">
    <p>On July 23nd of this year it will be exactly 5 years from the initial project
announcement on the <a href="http://web.archive.org/web/20120517182502/https://www.cloudkick.com/blog/2009/jul/23/libcloud-announced/">Cloudkick blog</a>.</p>

<p>We are going to celebrate this great milestone with a cake and drinks and we
would like to invite you to join us. The celebration will take place in a nice
bar during the <a href="https://ep2014.europython.eu/en/">EuroPython week</a> in Berlin, Germany.</p>

<div class="imginline">
  <p><img src="/images/posts/2014-07-07-libcloud-5th-birthday-celebration-during-europython-week-in-berlin/cake.png" class="img-responsive inline" /></p>
  <p class="img-caption">The cake is not a lie!</p>
</div>

<p>Celebration will be attended by Libcloud developers so this is also a great
opportunity for you to meet and hang with us in real-life and ask any questions
you might have about the project.</p>

<div class="imginline">
  <p><a href="https://www.eventbrite.com/e/apache-libclouds-5th-birthday-celebration-tickets-12180609531" target="_blank"><img src="/images/posts/2014-07-07-libcloud-5th-birthday-celebration-during-europython-week-in-berlin/eventbrite_page.jpg" class="img-responsive inline" /></a></p>
  <p class="img-caption">For more information visit the eventbrite page.</p>
</div>

<p>For more information, exact location and RSVP, please refer to the
<a href="https://www.eventbrite.com/e/apache-libclouds-5th-birthday-celebration-tickets-12180609531">Eventbrite page</a>. Keep in mind that RSVP is mandatory if you want to
attend the celebration.</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/conferences.html" rel="tag">conferences</a>, <a href="/blog/tags/events.html" rel="tag">events</a>, <a href="/blog/tags/celebrations.html" rel="tag">celebrations</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/06/26/libcloud-0-15-0-released.html">Libcloud 0.15.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jun 26, 2014</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.15.0.</p>

<p>This is a first release in the 0.15 series which means it brings many
new features, improvements and bug fixes.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>New compute driver for <a href="https://www.outscale.com/en/">Outscale SAS and Outscale INC cloud</a></li>
  <li>New compute driver for <a href="http://www.hpcloud.com/">HP Public Cloud (Helion)</a></li>
  <li>New compute driver for <a href="http://kili.io/">Kili public cloud</a></li>
  <li>Extension methods for the VPC Internet gateway management in the EC2 driver</li>
  <li>Lower memory usage and faster parsing of large XML responses when lxml
library is installed.</li>
  <li>and much more!</li>
</ul>

<p>Full change log can be found <a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-15-0">here</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.15.0 can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a></p>

<p>or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud<span class="o">==</span>0.15.0</code></pre>
</figure>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud<span class="o">==</span>0.15.0</code></pre>
</figure>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at
<a href="https://libcloud.readthedocs.org/en/v0.15.0/">https://libcloud.readthedocs.org/en/v0.15.0/</a>.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible!</p>

<p>Full list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-15-0">Changelog</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/05/13/libcloud-accepted-in-gsoc-2014.html">Libcloud accepted into Google Summer of Code 2014</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on May 13, 2014</span>

  <div class="post-content">
    <p>This is just a quick announcement that we have been granted one slot under
the Apache Softare Foundation umbrella in Google Summer of Code 2014.</p>

<p>Student Rahul Ranjan will work on a <a href="https://www.google-melange.com/gsoc/project/details/google/gsoc2014/rahulrrixe/5649050225344512">CLI interface for Libcloud</a>.</p>

<div class="imginline">
  <p><a href="/gsoc-2014.html">
  <img src="/images/gsoc/gsoc2014_2.jpg" class="img-responsive inline" />
  </a></p>
</div>

<p>If you are interested in other projects, students and organization which
have been accepted, please visit <a href="https://www.google-melange.com/gsoc/projects/list/google/gsoc2014">this page</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/gsoc.html" rel="tag">gsoc</a>, <a href="/blog/tags/gsoc2014.html" rel="tag">gsoc2014</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/02/17/sebastien-goasguen-joins-our-team.html">Sebastien Goasguen (sebgoa) joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Feb 17, 2014</span>

  <div class="post-content">
    <p>The Project Management Committee (PMC) for Apache Libcloud has asked Sebastien
Goasguen (sebgoa) to join us as a committer and a PMC member. We are pleased
to announce that he has accepted.</p>

<p>Sebastien is no stranger to the Libcloud project. He has been contributing and
actively participating in the Libcloud community for quite a while now.</p>

<p>On top of that, he is also a PMC member at the Apache CloudStack project and
our local “CloudStack guy”.</p>

<p>We are happy to have him and some direct CloudStack expertise in our team.</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/new-committer.html" rel="tag">new committer</a>, <a href="/blog/tags/new-pmc-member.html" rel="tag">new pmc member</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/02/14/call-for-participation-in-gsoc-2014.html">Call for Participation in Google Summer of Code 2014</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Feb 14, 2014</span>

  <div class="post-content">
    <div class="imginline">
  <p><a href="/gsoc-2014.html">
  <img src="/images/gsoc/gsoc2014_2.jpg" class="img-responsive inline" />
  </a></p>
</div>

<p>If you would like to participate in Google Summer of Code 2014 and work on
Apache Libcloud, we invite you to read the following blog post for more
information - <a href="http://www.tomaz.me/2014/02/11/libcloud-gsoc-cfp.html">Libcloud Google Summer of Code 2014 Call for Participation</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/gsoc.html" rel="tag">gsoc</a>, <a href="/blog/tags/gsoc2014.html" rel="tag">gsoc2014</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/02/08/libcloud-0-14-1-released.html">Libcloud 0.14.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Feb 08, 2014</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.14.1!</p>

<p>This release includes some bug-fixes, improvements and new features.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>New driver for <a href="https://libcloud.readthedocs.org/en//latest/compute/drivers/cloudsigma.html">CloudSigma API 2.0</a></li>
  <li>Improvements in the OpenStack driver</li>
  <li>Support for records with multiple values in the Route53 DNS driver</li>
  <li>Support for paging through zones and records in the Rackspace DNS driver</li>
</ul>

<p>Full change log can be found at <a href="https://libcloud.readthedocs.org/en//latest/changelog.html#changes-with-apache-libcloud-0-14-1">here</a>.</p>

<h3 id="download">Download</h3>

<p>The release can can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a> or installed using pip:</p>

<pre>
pip install apache-libcloud==0.14.1
</pre>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<pre>
pip install --upgrade apache-libcloud==0.14.1
</pre>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-14-1">https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-14-1</a></p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at <a href="https://libcloud.readthedocs.org/en/v0.14.1/">https://libcloud.readthedocs.org/en/v0.14.1/</a></p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en//latest/changelog.html#changes-with-apache-libcloud-0-14-1">CHANGES file</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201309.mbox/%3CCAJMHEmL4-Xuysx13z1EDwq-1K95eDyANqgY2tYGUT-MB5Sz4bQ%40mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/02/07/new-committer-alex-gaynor-joins-our-team.html">New committer Alex Gaynor joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Feb 07, 2014</span>

  <div class="post-content">
    <p>The Project Management Committee (PMC) for Apache Libcloud has asked Alex
Gaynor to become a committer and we are pleased to announce that they have
accepted.</p>

<p>We are glad to have him as a committer. Everyone, please help us welcome him
to the team :)</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/new-committer.html" rel="tag">new committer</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/2014/01/22/libcloud-0-14-0-released.html">Libcloud 0.14.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 22, 2014</span>

  <div class="post-content">
    <p>We are pleased to announce a long awaited Libcloud 0.14.0 release.</p>

<p>This is a first release in the 0.14 series which means it brings many
(and I mean many!) new features, changes and improvements.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>To make working with providers which support multiple regions easier and
more user-friendly, some of the drivers have moved away from the “one
class per region” to a single class plus “region” argument model. Those
drivers include: EC2, Rackspace, ElasticHosts, Joyent, CloudFiles.</li>
  <li>Addition of a programmatic way of updating the pricing file and ability
to use a custom pricing file. For more information, please see
https://libcloud.readthedocs.org/en/latest/compute/pricing.html#using-a-custom-pricing-file</li>
  <li>Addition of block storage management methods to the following drivers:
OpenNebula, OpenStack, EC2</li>
  <li>Unification of the extension arguments for handling security groups in
the EC2 and OpenStack driver</li>
  <li>New standard compute API for SSH key-pair management</li>
  <li>Many new features and improvements in the CloudStack driver</li>
  <li>New compute and load balancer driver for Google Compute Engine (GCE)</li>
  <li>Ability to export Libcloud’s DNS zone to BIND zone format</li>
  <li>and much more!</li>
</ul>

<p>Full change log can be found <a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-14-0-beta3">here</a> and <a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-14-0">here</a> (keep in mind that this
release also includes all the changes from 0.14.0-beta3).</p>

<h3 id="note-about-backward-compatibility">Note about backward compatibility</h3>

<p>Some of the changes noted above are backward incompatible. For more
information on what has changed and how to update your code to work with
a new release, please visit the <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-14-0">Upgrade Notes page</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.14.0 can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a></p>

<p>or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud<span class="o">==</span>0.14.0</code></pre>
</figure>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud<span class="o">==</span>0.14.0</code></pre>
</figure>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at
<a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a>.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible!</p>

<p>Full list of people who contributed to this release can be found in the
<a href="https://libcloud.readthedocs.org/en/latest/changelog.html#changes-with-apache-libcloud-0-14-0">Changelog</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2014/01/01/quick-update-about-0-13-3-release-and-digitalocean-vulnerability.html">Quick update about 0.13.3 release and DigitalOcean vulnerability</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jan 01, 2014</span>

  <div class="post-content">
    <p>This is a quick update about the recent 0.13.3 security release and the
DigitalOcean vulnerability.</p>

<p>DigitalOcean updated their blog post. The updated post says that
scrubbing is now enabled by default for all the newly issued destroy
requests:</p>

<blockquote>
  <p>All Destroys Default to Scrub</p>

  <p>We have updated the destroy method to scrub on all destroys, both for
web and API requests.</p>
</blockquote>

<p>This means that no action is required on the client side and upgrading
to 0.13.3 should not be necessary anymore.</p>

<p>References:</p>

<ul>
  <li><a href="https://twitter.com/digitalocean/status/418140046265294848">https://twitter.com/digitalocean/status/418140046265294848</a></li>
  <li><a href="https://digitalocean.com/blog_posts/transparency-regarding-data-security">https://digitalocean.com/blog_posts/transparency-regarding-data-security</a></li>
</ul>

  </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/security-release.html" rel="tag">security release</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/12/31/libcloud-0-13-3-released.html">Libcloud 0.13.3 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 31, 2013</span>

  <div class="post-content">
    <p>This release fixes a security issue with a potential leak of data contained on
a destroyed DigitalOcean node. Only users who are using a DigitalOcean driver
are affected.</p>

<h3 id="details-about-the-vulnerability">Details about the vulnerability</h3>

<p>DigitalOcean recently changed the default API behavior from scrub to
non-scrub when destroying a VM without notifying the customers and API
consumers.</p>

<p>Libcloud prior to this release doesn’t explicitly send “scrub_data” query
parameter when destroying a node. This means nodes which are destroyed using
Libcloud are vulnerable to later customers stealing data contained on them.</p>

<p>This release fixes that by always sending “scrub_data” query parameter when
destroying a DigitalOcean node.</p>

<p>If you are using a DigitalOcean driver, you are strongly encouraged to
upgrade (or downgrade if you are using 0.14.0-beta3 beta release) to this
release.</p>

<p>For more information, please see the <a href="/security.html#CVE-2013-6480">Security page</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.13.3 can be downloaded from
<a href="https://libcloud.apache.org/downloads.html">https://libcloud.apache.org/downloads.html</a></p>

<p>or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud<span class="o">==</span>0.13.3</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
https://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud<span class="o">==</span>0.13.3</code></pre>
</figure>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at
<a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a>.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible!</p>

<p>Full list of people who contributed to this release can be found in the
<a href="https://git-wip-us.apache.org/repos/asf?p=libcloud.git;a=blob;f=CHANGES;h=a06b0ed4c443f9f56784572a4e291e779de599e3;hb=a1fdac91ec9fdf699d77f9f9b01699de7f56171e#l3">CHANGES file</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/release-announcement.html" rel="tag">release announcement</a>, <a href="/blog/tags/security-release.html" rel="tag">security release</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/12/29/new-low-volume-announce-mailing-list.html">New low volume "announce" mailing list</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 29, 2013</span>

  <div class="post-content">
    <p>In addition to our existing users (<strong>users@libcloud.apache.org</strong>), developers
(<strong>dev@libcloud.apache.org</strong>) and commits (<strong>commits@libcloud.apache.org</strong>)
mailing list, we now also have a new very low volume announce mailing list -
<strong>announce@libcloud.apache.org</strong>.</p>

<p>The mailing list is moderated and will only be used for distributing important
project announcements such as information about new releases and other
important project updates.</p>

<p>You can subscribe to it by sending an email to
<a href="mailto:announce-subscribe@libcloud.apache.org">announce-subscribe@libcloud.apache.org</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></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/12/28/2013-in-retrospect-and-a-happy-new-year-from-the-libcloud-team.html">2013 in retrospect and a Happy New Year from the Libcloud team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 28, 2013</span>

  <div class="post-content">
    <p>Dear Libcloud users, developers and team members,</p>

<p>2013 is slowly coming to an end, and we would like to wish everyone a happy
and successful new year!</p>

<p>Now it’s also the time to look back at the things which have been accomplished,
important events which have happened and some statistics for 2013.</p>

<h3 id="important-events-and-milestones">Important Events and Milestones</h3>

<ul>
  <li>Two new committers have joined our team - <a href="/blog/2013/08/04/new-committer-john-carr-joins-our-team.html">John Carr</a>, <a href="/blog/2013/11/25/new-committers-brian-curtin-joins-our-team.html">Brian Curtin</a></li>
  <li>In June we held a Libcloud Design Day at the Rackspace San Francisco
office. See <a href="http://www.tomaz.me/2013/06/12/libcloud-design-day-recap-improving-libcloud-and-plans-for-the-future.html">Libcloud Design Day Recap</a> blog post for a recap.</li>
  <li>We have finally migrated from SVN to Git.</li>
  <li>We have started to work on new and improved documentation which is now
available on <a href="https://libcloud.readthedocs.org/en/latest/">ReadTheDocs</a>.</li>
  <li>In addition to the Apache Buildbot instance, our tests now also run on
<a href="https://travis-ci.org/apache/libcloud">Travis CI</a>.</li>
  <li>Key pair management methods have been promoted to be part of the base
compute API. See <a href="http://www.tomaz.me/2013/12/11/libcloud-update-key-pair-management-methods-are-now-part-of-the-base-api.html">Libcloud update - Key pair management methods are now
part of the base API</a> blog post for more information.</li>
</ul>

<h3 id="statistics">Statistics</h3>

<ul>
  <li><strong>197</strong> new JIRA issues have been opened (total of <strong>472</strong>). Out of those
197 issues, <strong>138</strong> are now marked as ‘resolved’.</li>
  <li>Github mirror stars: <strong>331</strong> (+65 YTD)</li>
  <li>Twitter followers: <strong>449</strong> (+149 YTD)</li>
  <li>Google+ page +1’s: <strong>1591</strong></li>
  <li>We had a total of <strong>5 releases</strong> (0.12.1, 0.12.3, 0.12.4, 0.13.0, 0.13.1,
0.13.2, 0.14.0-beta3)</li>
  <li>Combination of SVN and Git repository has had a total of <strong>963 commits</strong>.</li>
</ul>

<h3 id="sources">Sources</h3>

<p>Numbers listed above have been retrieved on <strong>26th of December, 2013</strong> from the
sources listed bellow:</p>

<ul>
  <li>Libcloud website - <a href="http://libcloud.apache.org/">http://libcloud.apache.org/</a></li>
  <li>Twitter account - <a href="https://twitter.com/libcloud">https://twitter.com/libcloud</a></li>
  <li>Google+ page - <a href="https://plus.google.com/b/100590055818889164025/100590055818889164025">Apache Libcloud</a></li>
  <li>Github mirror - <a href="https://github.com/apache/libcloud">https://github.com/apache/libcloud</a></li>
  <li>JIRA - <a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a></li>
  <li>PyPi - <a href="https://pypi.python.org/pypi/apache-libcloud/">https://pypi.python.org/pypi/apache-libcloud/</a></li>
  <li>Ohloh - <a href="https://www.ohloh.net/p/libcloud/">https://www.ohloh.net/p/libcloud/</a></li>
</ul>

<p>Those numbers and numbers for the past years are also available in a semi
machine readable format in a <a href="https://docs.google.com/spreadsheets/d/1k_UBpA_HiQcZvO_TPi12yfN0VwCk42R8CXFFX0FYUAM">Google Spreadsheet</a>.</p>

<h3 id="old-retrospect-blog-posts">Old retrospect blog posts</h3>

<ul>
  <li><a href="/blog/2012/12/26/2012-in-retrospect-and-happy-new-year-from-libcloud-team.html">2012 in retrospect and a Happy New Year from the Libcloud team</a></li>
  <li><a href="/blog/2011/12/30/2011-in-retrospect-and-happy-new-year-from-libcloud-team.html">2011 in retrospect and a Happy New Year from the Libcloud team</a></li>
</ul>

<p>Thanks again to everyone for their contributions and lets make 2014 even better
and more successful :)</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></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/11/25/new-committers-brian-curtin-joins-our-team.html">New committer Brian Curtin joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 25, 2013</span>

  <div class="post-content">
    <p>The Project Management Committee (PMC) for Apache Libcloud has asked Brian
Curtin to become a committer and we are pleased to announce that they have
accepted.</p>

<p>We are glad to have him as a committer. Everyone, please help us welcome him
to the team :)</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201311.mbox/%3CCAJMHEmJZO0%3DPLpLXe9W9wPXTLwh2iQ3x2xXy%2BWhqjdFBv2%2BHbw%40mail.gmail.com%3E">mailing list</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/new-committer.html" rel="tag">new committer</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/11/21/libcloud-0-14-0-beta3-released.html">Libcloud 0.14.0-beta3 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 21, 2013</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.14.0-beta3, a first
(beta) release in the 0.14.0 series.</p>

<p>The reason this is a beta and not a final release is that it includes some
pretty big changes (most notably the “region” argument change). I would
like those changes to get some more real-life testing before doing a final
release.</p>

<p>Being a first release in the 0.14.0 series means it brings many (and I mean
many!) new features, changes and improvements.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>To make working with providers which support multiple regions easier and
more user-friendly, some of the drivers have moved away from the “one
class per region” to a single class plus “region” argument model. Those
drivers include: EC2, Rackspace, ElasticHosts, Joyent, CloudFiles.</li>
  <li>Addition of a programmatic way of updating the pricing file and ability
to use a custom pricing file. For more information, please see the
<a href="https://libcloud.readthedocs.org/en/latest/compute/pricing.html#using-a-custom-pricing-file">documentation</a></li>
  <li>Addition of block storage management methods to the following drivers:
OpenNebula, OpenStack, EC2</li>
  <li>Unification of the extension arguments for handling security groups in
the EC2 and OpenStack driver</li>
  <li>Many new features and improvements in the CloudStack driver</li>
  <li>New compute and loadbalancer driver for Google Compute Engine (GCE)</li>
  <li>Ability to export Libcloud’s DNS zone to BIND zone format</li>
  <li>and much more!</li>
</ul>

<p>Some of the changes noted above are also backward incompatible. For more
information on what has changed and how to update your code to work with
a new release, please visit the <a href="https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-14-0">Upgrade Notes</a> section in our
documentation.</p>

<h3 id="other-non-code-changes-worth-a-mention">Other non-code changes worth a mention</h3>

<ul>
  <li>Tests now also run on travis-ci - <a href="https://travis-ci.org/apache/libcloud">https://travis-ci.org/apache/libcloud</a></li>
  <li>New documentation is now also available on RTD -
<a href="https://libcloud.readthedocs.org/en/latest/">https://libcloud.readthedocs.org/en/latest/</a></li>
</ul>

<p>Full change log can be found <a href="https://git-wip-us.apache.org/repos/asf?p=libcloud.git;a=blob;f=CHANGES;h=1a8d9e2072d4b49b5718b19f534573f9dfb224e4;hb=5ef0707b2a34f0e8520fe029e7313b7c57f15919#l3">here</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.14.0-beta3 can be downloaded from
http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud<span class="o">==</span>0.14.0-beta3</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this
is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud<span class="o">==</span>0.14.0-beta3</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at
https://libcloud.readthedocs.org/en/latest/upgrade_notes.html#libcloud-0-14-0
.</p>

<h3 id="documentation">Documentation</h3>

<p>Regular and API documentation is available at
https://libcloud.readthedocs.org/en/latest/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h2 id="thanks">Thanks</h2>

<p>Thanks to everyone who contributed and made this release possible!</p>

<p>Full list of people who contributed to this release can be found in the
<a href="https://git-wip-us.apache.org/repos/asf?p=libcloud.git;a=blob;f=CHANGES;h=1a8d9e2072d4b49b5718b19f534573f9dfb224e4;hb=5ef0707b2a34f0e8520fe029e7313b7c57f15919#l3">CHANGES file</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201311.mbox/%3CCAJMHEm%2B51RFT672GanfW9DKopcmDtZz2kkA7m0uufP1UupjeZw@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/09/05/libcloud-0-13-1-released.html">Libcloud 0.13.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Sep 05, 2013</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.13.1!</p>

<p>This is a bug-fix only release. Among some smaller bugs it also fixes
Content-Length regression which broke create and update operations in
the Bluebox Compute and Azure Storage driver (LIBCLOUD-362, LIBCLOUD-3901).</p>

<p>Full change log can be found at <a href="https://git-wip-us.apache.org/repos/asf?p=libcloud.git;a=blob;f=CHANGES;h=ca90c84e296ca82e2206eb86ed7364c588aad503;hb=602b6a7a27dca6990a38eb887e1d6615826387d5">here</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.13.0 can be downloaded from
http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this
is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.13.1/
.</p>

<p>We also have a new Sphinx documentation which can be found at
https://libcloud.apache.org/docs/.
Keep in mind though, that this documentation reflects state in trunk which
includes some backward incompatible changes which aren’t present in 0.13.1.
All the examples in the documentation which only work with trunk are
clearly marked with a note.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of
people who contributed to this release can be found in the <a href="https://git-wip-us.apache.org/repos/asf?p=libcloud.git;a=blob;f=CHANGES;h=ca90c84e296ca82e2206eb86ed7364c588aad503;hb=602b6a7a27dca6990a38eb887e1d6615826387d5">CHANGES file</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201309.mbox/%3CCAJMHEmL4-Xuysx13z1EDwq-1K95eDyANqgY2tYGUT-MB5Sz4bQ%40mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/08/04/new-committer-john-carr-joins-our-team.html">New committer John Carr joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Aug 04, 2013</span>

  <div class="post-content">
    <p>The Project Management Committee (PMC) for Apache Libcloud has asked John
Carr to become a committer and we are pleased to announce that they have
accepted.</p>

<p>We are glad to have him as a committer and a PMC member. Everyone, please
help me welcome him to the team :)</p>

<p>Source: <a href="https://mail-archives.apache.org/mod_mbox/libcloud-dev/201308.mbox/%3CCAJMHEm%2Bh7Fbqc8vWBw0PJbkzUKaDHWVziezOgECa2n7qESvLeA%40mail.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/new-committer.html" rel="tag">new committer</a>, <a href="/blog/tags/pmc.html" rel="tag">pmc</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/07/01/libcloud-0-13-0-released.html">Libcloud 0.13.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jul 01, 2013</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.13.0!</p>

<p>This release includes a lot of improvements and bug fixes.</p>

<p>Full change log can be found at <a href="https://git-wip-us.apache.org/repos/asf?p=libcloud.git;a=blob;f=CHANGES;h=640bd2f4db8bc11674fc8c1829922d0c79b733cd;hb=9c0d11a4cf7e588ad87c7e57311bbb1d955cc2a7">here</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.13.0 can be downloaded from
http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this
is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.13.0/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of
people who contributed to this release can be found in the <a href="https://git-wip-us.apache.org/repos/asf?p=libcloud.git;a=blob;f=CHANGES;h=640bd2f4db8bc11674fc8c1829922d0c79b733cd;hb=9c0d11a4cf7e588ad87c7e57311bbb1d955cc2a7">CHANGES file</a>.</p>

<p>Source: <a href="https://mail-archives.apache.org/mod_mbox/libcloud-dev/201307.mbox/%3CCAJMHEmJBU_aMREM0f0LD-nHZt6pWTt9WabfdxDPtDSy%2B1w7K8g%40mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/03/21/libcloud-0-12-3-released.html">Libcloud 0.12.3 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Mar 21, 2013</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.12.3!</p>

<p>This release is primarily a bug fix release and fixes Python 3.3,
deployment and some other issues.</p>

<p>Full change log can be found at
https://svn.apache.org/repos/asf/libcloud/tags/0.12.3/CHANGES</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.12.3 can be downloaded from
http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this
is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.12.3/
.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
 Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of
people who contributed to this release can be found in the CHANGES file
<a href="https://svn.apache.org/repos/asf/libcloud/tags/0.12.3/CHANGES">https://svn.apache.org/repos/asf/libcloud/tags/0.12.3/CHANGES</a>.</p>

<p>Source: <a href="https://mail-archives.apache.org/mod_mbox/libcloud-dev/201303.mbox/%3CCAJMHEmJDKsYOn%3DaVDyChdQCgHbKc1r2n0Wy4_UxGmdd-aXf-WQ%40mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2013/02/18/libcloud-0-12-1-released.html">Libcloud 0.12.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Feb 18, 2013</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.12.1!</p>

<p>This release includes many new features, improvements and bug-fixes.</p>

<h3 id="release-highlights">Release highlights</h3>

<ul>
  <li>New more efficient generator based approach for iterating over paginated
collections.</li>
  <li>New generator based method for iterating over containers
(iterate_containers).</li>
  <li>Old ENUM style provided constants have been replaced with a string
version. This allows users to dynamically register new providers using new
set_driver method.</li>
  <li>Support for multipart uploads in the Amazon S3 storage driver.</li>
  <li>New load balancer driver for Amazon Load Balancing (ELB) service.</li>
  <li>New storage driver for Azure Blog storage</li>
  <li>New “local storage” storage driver</li>
  <li>Support for multipart uploads in the S3 driver</li>
  <li>Allow user to specify which CA cert is used for verifying server SSL
certificate by setting “SSL_CERT_FILE” environment variable</li>
  <li>Drivers which use xmlrplic library now use Libcloud HTTP layer for making
HTTP requests. This means those drivers now support LIBCLOUD_DEBUG and SSL
cert validation functionality</li>
</ul>

<p>Full change log can be found at
https://svn.apache.org/repos/asf/libcloud/tags/0.12.1/CHANGES</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.12.1 can be downloaded from
http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this
is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.12.1/
.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>.
Don’t forget to attach an example and / or test which reproduces your
problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of
people who contributed to this release can be found in the CHANGES file
<a href="https://svn.apache.org/repos/asf/libcloud/tags/0.12.1/CHANGES">https://svn.apache.org/repos/asf/libcloud/tags/0.12.1/CHANGES</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201302.mbox/%3CCAJMHEmLc0RfSxM9UhXPeTwKiNDbZPsQs6SJMA1o3y1D4Cv+reA@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/12/28/new-committer-mahendra-maheshwara-joins-our-team.html">New committer Mahendra Maheshwara joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 28, 2012</span>

  <div class="post-content">
    <p>The Project Management Committee (PMC) for Apache Libcloud has asked
Mahendra Maheshwara to become a committer and we are pleased to announce
that they have accepted.</p>

<p>Mahendra Maheshwara has joined the Libcloud community fairly recently, but
he has already contributed multiple great patches -
https://issues.apache.org/jira/issues/?jql=project%20%3D%20LIBCLOUD%20AND%20reporter%20in%20(%22mahendra.m%22)
.</p>

<p>Giving him commit access will allow him to more directly contribute to the
project.</p>

<p>Everyone, please help me welcome him to the team :)</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201212.mbox/%3CCAJMHEmLyVg66Kb1Q9LRD1z9bSbtVFU=hTZGeWO2pc+s4qcEpow@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/new-committer.html" rel="tag">new committer</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/12/26/2012-in-retrospect-and-happy-new-year-from-libcloud-team.html">2012 in retrospect and a Happy New Year from the Libcloud team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 26, 2012</span>

  <div class="post-content">
    <p>Dear users, developers and team members!</p>

<p>2012 is slowly coming to an end and Libcloud team wishes everyone a happy
and successful new year 2013!</p>

<p>2012 has been another great year for us and we have surpassed 2011 in
pretty much every aspect.</p>

<p>Here is a short list of things which have been accomplished and important
events which have happened in 2012:</p>

<ul>
  <li>One new committer Ilgiz Islamgulov (ilgiz) has joined the team.</li>
  <li>We have another new commiter joining our team soon (Mahendra M).
Currently he is undergoing a process of submitting his ICLA.</li>
  <li>134 new JIRA issues have been opened (total of 271). Out of those 134
issues, 111 are now marked as ‘resolved’.</li>
  <li>SVN repository has had a total of 320 commit. More than 50% of those
commits were patches from external contributors.</li>
  <li>We had our first Google Summer of Code student which worked on a project
named “Libcloud REST” (https://github.com/islamgulov/libcloud.rest). The
goal of the project is to expose Libcloud functionality over HTTP.</li>
  <li>Tomaz gave a talk titled “Avoiding Vendor Lock-In Using Apache Libcloud”
at CloudOpen 2012 in San Diego</li>
  <li>We now finally have some more user friendly documentation and examples on
the website - http://libcloud.apache.org/docs/</li>
  <li>We held a first in person meetup at the Rackspace San Francisco office in
the beginning of the year (http://libcloudmeetup.eventbrite.com/)</li>
  <li>We had a total of 7 releases (0.8.0, 0.9.1, 0.10.1, 0.11.0, 0.11.1,
0.11.3, 0.11.4) and over 70.000 downloads / installs on PyPi (
http://pypi.python.org/pypi/apache-libcloud/)</li>
  <li>Github mirror has been starred by 266 users (
https://github.com/apache/libcloud)</li>
</ul>

<p>Thanks again to everyone for their work and contributions and lets make
2013 even better :)</p>

<p>I will post those numbers in a more machine readable format (JSON) in the
next couple of weeks. This way it will be easier for us to track those
metrics on a year over year basis.</p>

<p>Numbers retrieved on: 2012-12-25.
Sources for those numbers: JIRA, Libcloud website, PyPi, Ohloh.net, Google
Analytics</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201212.mbox/%3CCAJMHEmK-Y47qbqpSQjNfWxK-1efqiifvpRgE-tO8q-QLTk-EYg@mail.gmail.com%3E">mailing list post</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></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/11/19/libcloud-0-11-4-released.html">Libcloud 0.11.4 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 19, 2012</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.11.4!</p>

<p>This release is a bug fix release and contains no new features.</p>

<p>Next release which will contain new features and some backward incompatible
changes will happen in the 0.12.x series in the next couple of weeks.</p>

<p>Bug fixes:</p>

<ul>
  <li>Fix some of tests failures which happened in Python 3.3 due to randomized
dictionary ordering.</li>
  <li>Fix a bug where a numeric instead of a string value was used for the
content-length header in VCloud driver.</li>
  <li>Don’t ignore ex_force_service_region argument in the CloudFiles driver.</li>
  <li>Fix a bug which caused the connection to not be closed when using Python
2.6 and calling get_object on an object which doesn’t exist in the S3
driver.</li>
  <li>Update ‘if type’ checks in the update_record methods to behave correctly
if users passes in RecordType.A with a value of 0 - if type is not None.</li>
</ul>

<p>Full change log can be found at
<a href="https://svn.apache.org/viewvc/libcloud/tags/0.11.4/CHANGES?revision=r1411030&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.11.4/CHANGES?revision=r1411030&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.11.4 can be downloaded from
http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case,
please use the main Apache mirror - http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.11.4/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker &lt;
https://issues.apache.org/jira/browse/LIBCLOUD&gt;. Don’t forget to attach an
example and / or
test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file <a href="https://svn.apache.org/viewvc/libcloud/tags/0.11.3/CHANGES?revision=r1388947&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.11.3/CHANGES?revision=r1388947&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201211.mbox/%3CCAJMHEmL73OCjiNqg0QGPWb1Cc2JnQ4OWjXs5ah-sU%2BA%3DOwPUTg%40mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/11/16/new-committer-ilgiz-islamgulov-joins-the-team.html">New committer Ilgiz Islamgulov joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 16, 2012</span>

  <div class="post-content">
    <p>The Project Management Committee (PMC) for Apache Libcloud
has asked Ilgiz Islamgulov to become a committer and we are pleased
to announce that they have accepted.</p>

<p>Ilgiz worked on the Libcloud REST GSoC project
(http://libcloud.apache.org/gsoc-2012.html) this summer and he has made a
great progress on it.</p>

<p>Giving him commit access will allow him to more directly contribute to the
project and work on integrating Libcloud REST into main line.</p>

<p>Everyone, please help me welcome him to the team :)</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201211.mbox/%3CCAJMHEmJmRDdQbfRSxOBTueSJ8u4-VgU8YaeP5LcJ2gwubfNF2g%40mail.gmail.com%3E">mailing list</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/new-committer.html" rel="tag">new committer</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/09/25/libcloud-0-11-3-released.html">Libcloud 0.11.3 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Sep 25, 2012</span>

  <div class="post-content">
    <p>We are pleased to announce the release of Libcloud 0.11.3!</p>

<h3 id="release-highlights">Release highlights</h3>

<p><strong>Compute</strong></p>

<ul>
  <li>Add new Rackspace Nova driver for Chicago (ORD) location</li>
  <li>Add new methods for managing storage volumes and other extenstion methods
to the IBM SCE driver.</li>
  <li>Allow user to pass ‘timeout’ argument to the ‘deploy_node’ method</li>
</ul>

<p><strong>Bug fixes</strong></p>

<ul>
  <li>Fix a bug with the Libcloud SSL verification code. Code was too strict
and didn’t allow “-“ character in the sub-domain when using a wildcard
certificate.</li>
</ul>

<p>Full change log can be found at
<a href="https://svn.apache.org/viewvc/libcloud/tags/0.11.3/CHANGES?revision=r1388947&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.11.3/CHANGES?revision=r1388947&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.11.3 can be downloaded from
http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.11.3/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / ortest which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file <a href="https://svn.apache.org/viewvc/libcloud/tags/0.11.3/CHANGES?revision=r1388947&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.11.3/CHANGES?revision=r1388947&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/www-announce/201209.mbox/%3CCAJMHEmLn+MV_pcNZv03PW5wuS5c=O8cFdqMH8LFtaUr1gggkdw@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/08/22/libcloud-0-11-1-released.html">Libcloud 0.11.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Aug 22, 2012</span>

  <div class="post-content">
    <p>This release fixes a possible SSL man-in-the-middle vulnerability inside
the code which performs the SSL certificate validation. For more
information about the vulnerability, please see the “Security” page -
<a href="http://libcloud.apache.org/security.html">http://libcloud.apache.org/security.html</a>.</p>

<p>Everyone using an older version is strongly encouraged to upgrade to this
release.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.11.1 can be downloaded from
http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.11.1/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to the researchers from the University of Texas at Austin
(Martin Georgiev, Suman Jana and Vitaly Shmatikov) who discovered this
vulnerability.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/www-announce/201208.mbox/%3CCAJMHEmL958gN+GZT0tWDM9jVmMBj+w0qqY8TYXbJUNPwdW+6yA@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a>, <a href="/blog/tags/security-release.html" rel="tag">security release</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/07/30/libcloud-0-11-0-released.html">Libcloud 0.11.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jul 30, 2012</span>

  <div class="post-content">
    <p>The Apache Libcloud team is pleased to announce the release of Libcloud
0.11.0!</p>

<p>Libcloud is a Python library that abstracts away the differences among
multiple cloud provider APIs. It allows users to manage cloud services
(servers, storage, load balancers, DNS) offered by many different providers
 through a single, unified and easy to use API.</p>

<h3 id="release-highlights">Release highlights</h3>

<p><strong>General</strong></p>

<ul>
  <li>Install test files when installing the library. Tests module can now be
imported by doing something like this: “from libcloud import test”</li>
</ul>

<p><strong>Compute</strong></p>

<ul>
  <li>New standard API and methods for managing storage volumes. Base API
consists of the following methods: create_volume, destroy_volume,
attach_volume, detach_volume.</li>
  <li>New driver for KT UCloud (http://home.ucloud.olleh.com/main.kt) based
on the CloudStack driver.</li>
  <li>New Gridspot driver with a basic list and destroy functionality.</li>
</ul>

<p><strong>Bug fixes</strong></p>

<ul>
  <li>Plenty of them, please see the CHANGES file.</li>
</ul>

<p>For a full list of changes, please see the CHANGES file
<a href="https://svn.apache.org/viewvc/libcloud/tags/0.11.0/CHANGES?revision=r1364892&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.11.0/CHANGES?revision=r1364892&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.10.1 can be downloaded from http://libcloud.apache.org/downloads.html
or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case,
please use the main Apache mirror - http://www.apache.org/dist/libcloud.</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible
changes and how to preserve the old behavior when this is possible
can be found at http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.11.1/</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or
test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible!
Full list of people who contributed to this release can be found in the
CHANGES file <a href="https://svn.apache.org/viewvc/libcloud/tags/0.11.0/CHANGES?revision=r1364892&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.11.0/CHANGES?revision=r1364892&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/www-announce/201207.mbox/%3CCAJMHEmLcSZi4bYmUaZtF_q=npc--DpVbTEH-Z+f0TCd2iteS-A@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/05/24/libcloud-0-10-1-released.html">Libcloud 0.10.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on May 24, 2012</span>

  <div class="post-content">
    <p>Libcloud team is pleased to announce the release of Libcloud 0.10.1!</p>

<h3 id="release-highlights">Release highlights</h3>

<p><strong>General</strong></p>

<ul>
  <li>Allow user to specify which IP to use when calling deploy_node
(defaults to ‘public_ips’). Previously it only worked with public IP, now
user can pass ‘private_ips’ as an argument and SSH client will try to
connect to the node first private IP address.</li>
</ul>

<p><strong>Compute</strong></p>

<ul>
  <li>New driver for Joyent cloud (http://www.joyentcloud.com/)</li>
  <li>New driver for VCL cloud (
http://www.educause.edu/blog/hes8/CloudComputingandtheVirtualCom/167931)</li>
  <li>A lot of improvements and new features in the Brightbox driver</li>
  <li>Support for Vmware vCloud version 1.5</li>
  <li>Modify ParamikoSSHClient to connect to the SSH agent and automatically
look for private keys in ~/.ssh if the ‘auth’ and ‘ssh_key’ argument is not
specified when calling deploy_node.</li>
  <li>Modify IBM driver so it works with IBM Smart Cloud Enterprise</li>
</ul>

<p><strong>Storage</strong></p>

<ul>
  <li>Support for uploading large files in the CloudFiles driver</li>
  <li>New driver for OpenStack Swift installations based on the CloudFiles
driver</li>
</ul>

<p><strong>Bug fixes</strong></p>

<ul>
  <li>Fix a bug in the CloudSigma Las Vegas compute driver</li>
</ul>

<p>For a full list of changes, please see the CHANGES file
<a href="https://svn.apache.org/viewvc/libcloud/tags/0.10.1/CHANGES?revision=r1340892&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.10.1/CHANGES?revision=r1340892&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.10.1 can be downloaded from
http://libcloud.apache.org/downloads.html or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible changes
and how to preserve the old behavior when this is possible can be found at
http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.10.1/</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file <a href="https://svn.apache.org/viewvc/libcloud/tags/0.10.1/CHANGES?revision=r1340892&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.10.1/CHANGES?revision=r1340892&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201205.mbox/%3CCAJMHEmKtqtkWsTHVYeO-ijytw9caQ4p%2B-ip7And3aPJhKuA8vA%40mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</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 class="post">
  
    <h2 class="post-title"><a href="/blog/2012/04/01/libcloud-0-9-1-released.html">Libcloud 0.9.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Apr 01, 2012</span>

  <div class="post-content">
    <p>Libcloud team is pleased to announce the release of Libcloud 0.9.1!</p>

<p>Release highlights:</p>

<ul>
  <li>A lot of improvements and additional functionality in the OpenStack
driver. Now a generic OpenStack driver (Provider.OPENSTACK) also works with
devstack.org and trystack.org installations</li>
  <li>Improvements and better exception propagation in the deploy_node method</li>
  <li>New driver for ElasticHosts Los Angeles and Toronto location</li>
  <li>Support for new EC2 instance type - m1.medium</li>
</ul>

<p>Bug fixes:</p>

<ul>
  <li>Don’t lowercase special header names in the Amazon S3 storage driver.
This fixes a bug with multi-objects delete calls.</li>
  <li>Properly handle OpenStack providers which return public IP addresses
under the ‘internet’ key in the ‘addresses’ dictionary</li>
  <li>Make create_node in Linode driver return a Node instance instead of a
listen of Node instances</li>
</ul>

<p>For a full list of changes, please see the CHANGES file
<a href="https://svn.apache.org/viewvc/libcloud/tags/0.9.1/CHANGES?revision=r1307716&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.9.1/CHANGES?revision=r1307716&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.9.1 can be downloaded from
http://libcloud.apache.org/downloads.html or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible changes
and how to preserve the old behavior when this is possible can be found at
http://libcloud.apache.org/upgrade-notes.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.9.1/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file <a href="https://svn.apache.org/viewvc/libcloud/tags/0.9.1/CHANGES?revision=r1307716&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.9.1/CHANGES?revision=r1307716&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201204.mbox/%3CCAJMHEmJzeGL%2BU1PNeX0T-1dcxUC1um88jQTAmskZ-mXTQ3QLGw%40mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2012/02/08/libcloud-0-8-0-released.html">Libcloud 0.8.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Feb 08, 2012</span>

  <div class="post-content">
    <p>Libcloud team is pleased to announce the release of Libcloud 0.8.0!</p>

<p>Release highlights:</p>

<ul>
  <li>Support for handling compressed (gzip, deflate) responses</li>
  <li>Support for new Amazon EC2 location - South America (Sao Paulo)</li>
</ul>

<p>Other notable changes:</p>

<ul>
  <li>Many improvements and additions of extension methods in the OpenStack
compute driver</li>
  <li>Many improvements and additions of extension methods in the Rackspace
load-balancer driver</li>
  <li>Improvements in the OpenNebula compute driver</li>
</ul>

<p>For a full list of changes, please see the CHANGES file
<a href="https://svn.apache.org/viewvc/libcloud/tags/0.8.0/CHANGES?revision=r1240459&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.8.0/CHANGES?revision=r1240459&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.8.0 can be downloaded from
http://libcloud.apache.org/downloads.html or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible changes
and how to preserve the old behavior when this is possible can be found at
http://libcloud.apache.org/upgrade-notes-0-8.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.8.0/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file <a href="https://svn.apache.org/viewvc/libcloud/tags/0.8.0/CHANGES?revision=r1240459&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.8.0/CHANGES?revision=r1240459&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.us.apache.org/mod_mbox/www-announce/201202.mbox/%3CCAJMHEmJJcigBO+ZoSyxFGvc5Z37t-t3KKHBHyyMi7L-J4-Y03A@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/12/30/2011-in-retrospect-and-happy-new-year-from-libcloud-team.html">2011 in retrospect and a Happy New Year from the Libcloud team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 30, 2011</span>

  <div class="post-content">
    <p>Dear users &amp; developers,</p>

<p>First of all, Libcloud team wishes everyone a Happy New Year 2012!</p>

<p>2011 has been a great year for us and we have accomplished a lot of things:</p>

<ul>
  <li>Website has been ported to the Apache CMS and updated with a lot of new
content, including documentation</li>
  <li>In May we have graduated from the incubator to a top level project</li>
  <li>Two new committers have joined the team (Tomaz Muraus, Hutson Betts)</li>
  <li>We have grown from supporting a single API (cloud servers) to supporting
four different APIs (cloud servers, load balancers, cloud storage, dns)</li>
  <li>We have introduced support for Python 3</li>
  <li>We have released a total of 7 new versions</li>
  <li>We have received many patches by external contributors</li>
  <li>We have held two development sprints (PyCon, EuroPython)</li>
  <li>Code wise we have grown from ~4300 LOC to ~14300 LOC (excluding tests)</li>
</ul>

<p>Lets try to make 2012 even better :)</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201112.mbox/%3CCAJMHEmL1D-HuCj4LSH-mF1bP_Of6XwEfuP1Y74_2APeD-8OrFA@mail.gmail.com%3E">mailing list post</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></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/12/09/libcloud-0-7-1-released.html">Libcloud 0.7.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Dec 09, 2011</span>

  <div class="post-content">
    <p>Libcloud team is pleased to announce the release of Libcloud 0.7.1!</p>

<p>This release represents another big milestone for us and introduces a
support for Python 3!</p>

<p>Other notable changes:</p>

<ul>
  <li>New Las Vegas location for the CloudSigma provider</li>
  <li>Improvements to the OpenStack driver</li>
  <li>Improvements to the OpenNebula driver</li>
  <li>Support for Amazon EC2 new “Cluster Compute Eight Extra Large” instance
size</li>
</ul>

<p>This release also removes old, deprecated (pre-0.5) paths. If you still
haven’t updated your code you need to do it now otherwise it won’t work
with 0.7.1 and future releases.</p>

<p>Script which can help you with the migration from the old style paths to
the new ones can be found at
http://libcloud.apache.org/upgrade-notes-0-7.html.</p>

<p>For a full list of changes, please see the CHANGES file
<a href="https://svn.apache.org/viewvc/libcloud/tags/0.7.1/CHANGES?revision=1210679&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.7.1/CHANGES?revision=1210679&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.7.1 can be downloaded from
http://libcloud.apache.org/downloads.html or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible changes
and how to preserve the old behavior when this is possible can be found at
http://libcloud.apache.org/upgrade-notes-0-7.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.7.1/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker &lt;
https://issues.apache.org/jira/browse/LIBCLOUD&gt;. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file <a href="https://svn.apache.org/viewvc/libcloud/tags/0.7.1/CHANGES?revision=1210679&amp;view=markup">https://svn.apache.org/viewvc/libcloud/tags/0.7.1/CHANGES?revision=1210679&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201112.mbox/%3CCAJMHEm+qKuSarmvQZ4H1PVUkv6L3vssjQEHs+3MCtSJ9hfBwOw@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/11/22/new-committer-hutson-betts-join-our-team.html">New committer Hutson Betts joins our team</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 22, 2011</span>

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

<p>I just wanted to let everyone know that the Libcloud PMC has decided to
invite a new committer - Hutson Betts (hbetts).</p>

<p>He has previously mostly contributed to the OpenNebula driver and the
networking API.</p>

<p>We believe that granting him the committer status will allow him to more
easily and directly contribute to the project.</p>

<p>Please help us welcome him!</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201111.mbox/%3CCAJMHEm+08-1MMCgHDZgULc+StDiwgR+_krVZvHOJF0odcU_OWg@mail.gmail.com%3E">mailing list</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/new-committer.html" rel="tag">new committer</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/11/17/libcloud-0-6-2-released.html">Libcloud 0.6.2 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 17, 2011</span>

  <div class="post-content">
    <p>Libcloud team is pleased to announce the release of Libcloud 0.6.2!</p>

<p>This is primary a bug-fix release and includes the following bug-fixes:</p>

<ul>
  <li>Fix the PollingConnection class and actually use the poll_interval class
variable (previously it was ignored). This bug-fix affects Rackspace Cloud
DNS driver, CloudStack and Ninefold compute driver.</li>
  <li>Fix a bug in the Rackspace Cloud DNS driver exception handling and throw
an Exception if an unexpected status code is returned.</li>
</ul>

<p>Besides the bug-fixes it also includes some new features:</p>

<ul>
  <li>Support for Amazon’s new location (Oregon)</li>
  <li>Expose CloudStack provider. This way it can be used with an arbitrary
CloudStack installation and not just with the provider drivers which
sub-class it (e.g. Ninefold.com driver).</li>
</ul>

<p>For a full list of changes, please see the CHANGES file
<a href="https://svn.apache.org/viewvc/libcloud/branches/0.6.x/CHANGES?revision=1202009&amp;view=markup">https://svn.apache.org/viewvc/libcloud/branches/0.6.x/CHANGES?revision=1202009&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.6.2 can be downloaded from
http://libcloud.apache.org/downloads.html or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible changes
and how to preserve the old behavior when this is possible can be found at
http://libcloud.apache.org/upgrade-notes-0-6.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.6.2/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker &lt;
https://issues.apache.org/jira/browse/LIBCLOUD&gt;. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file
<a href="https://svn.apache.org/viewvc/libcloud/branches/0.6.x/CHANGES?revision=1202009&amp;view=markup">https://svn.apache.org/viewvc/libcloud/branches/0.6.x/CHANGES?revision=1202009&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201111.mbox/%3CCAJMHEmJTN407_JJRfnwDuJxNsWCupEGc0cXWxs%3DM-n8HoHoQKQ%40mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/11/09/libcloud-0-6-1-released.html">Libcloud 0.6.1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Nov 09, 2011</span>

  <div class="post-content">
    <p>Libcloud team is pleased to announce the release of Libcloud 0.6.1!</p>

<p>This release represents a big milestone for us and includes many
improvements and new drivers, but the most important thing is a brand new
DNS API.</p>

<p>DNS API allows users to manage DNS service provided by many different
providers. This release includes a driver for Linode DNS (
http://www.linode.com/features.cfm), Zerigo DNS (http://www.zerigo.com/)
and Rackspace Cloud DNS (
http://www.rackspace.com/cloud/cloud_hosting_products/dns/). In the future
we also plan to expand it (hopefully with your help) and add new drivers
for providers such as Amazon and others.</p>

<p>Other notable changes, bug-fixes and improvements:</p>

<p><strong>Documentation</strong></p>

<ul>
  <li>New documentation which is available at http://libcloud.apache.org/docs/</li>
</ul>

<p><strong>General</strong></p>

<ul>
  <li>SSL certificate validation is now enabled by default. If no CA
certificate files are found on startup, an exception is thrown.</li>
</ul>

<p><strong>Compute</strong></p>

<ul>
  <li>New driver for Ninefold.com (also a first driver for public Australian
cloud provider in Libcloud)</li>
  <li>Support for OpenStack 1.1 API and many other improvements in the
OpenStack driver</li>
  <li>Linode driver now support a new Japan location</li>
  <li>Support for deployment using an SSH key</li>
  <li>Amazon EC2 driver now supports deploy functionality using an SSH key</li>
</ul>

<p><strong>Storage</strong></p>

<ul>
  <li>New driver for Google storage (http://code.google.com/apis/storage/)</li>
  <li>New driver for Ninefold.com storage (http://ninefold.com/cloud-storage/)</li>
</ul>

<p>Load Balancer:</p>

<ul>
  <li>New driver for ninefold.com (
https://ninefold.com/support/display/SPT/Load+Balancing)</li>
  <li>Rackspace driver now also supports UK location</li>
</ul>

<p>Any many other improvements and bug fixes!</p>

<p>For a full list of changes, please see the CHANGES file
<a href="https://svn.apache.org/viewvc/libcloud/trunk/CHANGES?revision=1198753&amp;view=markup">https://svn.apache.org/viewvc/libcloud/trunk/CHANGES?revision=1198753&amp;view=markup</a>.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.6.1 can be downloaded from
http://libcloud.apache.org/downloads.html or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible changes
and how to preserve the old behavior when this is possible can be found at
http://libcloud.apache.org/upgrade-notes-0-6.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.6.1/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<p>###Thanks</p>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file
<a href="https://svn.apache.org/viewvc/libcloud/trunk/CHANGES?revision=1198753&amp;view=markup">https://svn.apache.org/viewvc/libcloud/trunk/CHANGES?revision=1198753&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201111.mbox/%3CCAJMHEm+8XX704mSY4qw4P0YSBjGK=0SWCKjzSHBe8sLD__2UnA@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/10/19/libcloud-0-6-0-beta1-released.html">Libcloud 0.6.0-beta1 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Oct 19, 2011</span>

  <div class="post-content">
    <p>Libcloud team is pleased to announce the release of Libcloud 0.6.1!</p>

<p>This release represents a big milestone for us and includes many
improvements and new drivers, but the most important thing is a brand new
DNS API.</p>

<p>DNS API allows users to manage DNS service provided by many different
providers. This release includes a driver for Linode DNS (
http://www.linode.com/features.cfm), Zerigo DNS (http://www.zerigo.com/)
and Rackspace Cloud DNS (
http://www.rackspace.com/cloud/cloud_hosting_products/dns/). In the future
we also plan to expand it (hopefully with your help) and add new drivers
for providers such as Amazon and others.</p>

<p>Other notable changes, bug-fixes and improvements:</p>

<p><strong>Documentation</strong></p>

<ul>
  <li>New documentation which is available at http://libcloud.apache.org/docs/</li>
</ul>

<p><strong>General</strong></p>

<ul>
  <li>SSL certificate validation is now enabled by default. If no CA
certificate files are found on startup, an exception is thrown.</li>
</ul>

<p><strong>Compute</strong></p>

<ul>
  <li>New driver for Ninefold.com (also a first driver for public Australian
cloud provider in Libcloud)</li>
  <li>Support for OpenStack 1.1 API and many other improvements in the
OpenStack driver</li>
  <li>Linode driver now support a new Japan location</li>
  <li>Support for deployment using an SSH key</li>
  <li>Amazon EC2 driver now supports deploy functionality using an SSH key</li>
</ul>

<p><strong>Storage</strong></p>

<ul>
  <li>New driver for Google storage (http://code.google.com/apis/storage/)</li>
  <li>New driver for Ninefold.com storage (http://ninefold.com/cloud-storage/)</li>
</ul>

<p><strong>Load Balancer</strong></p>

<ul>
  <li>New driver for ninefold.com (
https://ninefold.com/support/display/SPT/Load+Balancing)</li>
  <li>Rackspace driver now also supports UK location</li>
</ul>

<p>Any many other improvements and bug fixes!</p>

<p>For a full list of changes, please see the CHANGES file
<a href="https://svn.apache.org/viewvc/libcloud/trunk/CHANGES?revision=1198753&amp;view=markup">https://svn.apache.org/viewvc/libcloud/trunk/CHANGES?revision=1198753&amp;view=markup</a></p>

<h3 id="download">Download</h3>

<p>Libcloud 0.6.1 can be downloaded from
http://libcloud.apache.org/downloads.html or installed using pip:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install </span>apache-libcloud</code></pre>
</figure>

<p>It is possible that the file hasn’t been synced to all the mirrors yet. If
this is the case, please use the main Apache mirror -
http://www.apache.org/dist/libcloud</p>

<h3 id="upgrading">Upgrading</h3>

<p>If you have installed Libcloud using pip you can also use it to upgrade it:</p>

<figure class="highlight">
  <pre><code class="language-bash" data-lang="bash">pip <span class="nb">install</span> <span class="nt">--upgrade</span> apache-libcloud</code></pre>
</figure>

<h3 id="upgrade-notes">Upgrade notes</h3>

<p>A page which describes backward incompatible or semi-incompatible changes
and how to preserve the old behavior when this is possible can be found at
http://libcloud.apache.org/upgrade-notes-0-6.html.</p>

<h3 id="documentation">Documentation</h3>

<p>API documentation can be found at http://libcloud.apache.org/apidocs/0.6.1/.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker
<a href="https://issues.apache.org/jira/browse/LIBCLOUD">https://issues.apache.org/jira/browse/LIBCLOUD</a>. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<h3 id="thanks">Thanks</h3>

<p>Thanks to everyone who contributed and made this release possible! Full
list of people who contributed to this release can be found in the CHANGES
file
<a href="https://svn.apache.org/viewvc/libcloud/trunk/CHANGES?revision=1198753&amp;view=markup">https://svn.apache.org/viewvc/libcloud/trunk/CHANGES?revision=1198753&amp;view=markup</a>.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201111.mbox/%3CCAJMHEm+8XX704mSY4qw4P0YSBjGK=0SWCKjzSHBe8sLD__2UnA@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/09/01/libcloud-on-floss-weekly.html">Episode about Libcloud on FLOSS Weekly podcast</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Sep 01, 2011</span>

  <div class="post-content">
    <p>Tomaz Muraus has been guest on a <a href="http://twit.tv/show/floss-weekly/">FLOSS weekly podcast</a> where he talked
about Apache Libcloud.</p>

<p>For a recording and show notes, please see the official show page -
<a href="http://twit.tv/show/floss-weekly/181">FLOSS Weekly 181</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/podcasts.html" rel="tag">podcasts</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/07/04/libcloud-0-5-2-released.html">Libcloud 0.5.2 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jul 04, 2011</span>

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

<p>I would like to announce Libcloud 0.5.2. This release primary fixes two bugs
which were introduced in Libcloud 0.5.0 and improves listing of the objects
in the containers which contain more objects that fit into a single
response.</p>

<h3 id="notable-changes-bug-fixes-and-improvements">Notable changes, bug-fixes and improvements</h3>

<p><strong>Compute</strong></p>

<ul>
  <li>Fix a regression in the <code class="language-plaintext highlighter-rouge">deploy_node()</code> method and make it more robust</li>
  <li>Fix a regression in the Nimbus driver create_node() method</li>
  <li>Improved node name and tag handling in the Amazon EC2 driver</li>
  <li>Improved pricing and response handling in the OpenStack driver</li>
  <li>New driver for SkaliCloud (skalicloud.com)</li>
  <li>New driver for ServerLove (serverlove.com)</li>
</ul>

<p><strong>Storage</strong></p>

<ul>
  <li>Fix handling of the containers with a lot of objects. Now an iterator
object is returned when user calls <code class="language-plaintext highlighter-rouge">list_container_objects()</code> method
and this object transparently handles pagination.</li>
</ul>

<p>For a full list of changes, please check the CHANGES file &lt;
https://github.com/apache/libcloud/blob/0.5.2/CHANGES&gt;.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.5.2 can be downloaded from
http://libcloud.apache.org/downloads.html or installed using pip - pip
install apache-libcloud</p>

<p>It is possible that the file hasn’t been synced to all the mirrors yet so if
this is the case, please use the apache mirror -
http://www.apache.org/dist/libcloud</p>

<h3 id="documentation">Documentation*</h3>

<p>API documentation can be found at https://libcloud.apache.org/apidocs/0.5.2/</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker &lt;
https://issues.apache.org/jira/browse/LIBCLOUD&gt;. Don’t forget to attach an
example and / or test which reproduces your problem.</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201107.mbox/%3CCAJMHEm+-=3NxsZj+n+bogmYzGsxDJQOU_2aJbuNS77nmnsekJw@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/06/06/libcloud-sprint-will-be-held-at-europython-2011.html">Libcloud sprint will be held at EuroPython 2011</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Jun 06, 2011</span>

  <div class="post-content">
    <p>Libcloud sprint will be held at EuroPython 2011 in Florence, Italy. For more
information, please refer to the <a href="http://mail-archives.apache.org/mod_mbox/libcloud-users/201106.mbox/%3CBANLkTiniHVi+EYpo6iBYvA-BxwPkZmfSig@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/sprints.html" rel="tag">sprints</a>, <a href="/blog/tags/europython.html" rel="tag">europython</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/05/25/libcloud-0-5-0-released.html">Libcloud 0.5.0 released</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on May 25, 2011</span>

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

<p>I would like to announce Libcloud 0.5.0. This version represents a big
milestone, because it includes many new features, drivers, improvement and
two totally new API’s - storage and load-balancers.</p>

<h3 id="major-changes-and-features-since-the-last-release">Major changes and features since the last release</h3>

<p><strong>New Storage API</strong></p>

<p>Storage API which allows you to manage cloud storage has been added to the
core. Currently two provider drivers are available (Rackspace Cloud Files
and Amazon S3), but you can expect more drivers in the future releases.</p>

<p><strong>New load-balancer API</strong></p>

<p>Load-balancer API which allows you to manage load-balancers as a service
(LBaaS) has been added to the core. Currently two provider drivers are
available (Rackspace and GoGrid), but you can expect more drivers in the
future releases.</p>

<p><strong>New compute drivers</strong></p>

<p>This release includes 5 new compute drivers. The compute API now supports a
total of 24 different providers.</p>

<ul>
  <li>Bluebox (contributed by Christian Paredes)</li>
  <li>Gandi.net (contributed by Aymeric Barantal)</li>
  <li>Nimbus (contributed by David LaBissoniere)</li>
  <li>OpenStack (contributed by Roman Bogorodskiy)</li>
  <li>Opsource.net cloud (contributed by Joe Miller)</li>
</ul>

<h3 id="api-changes">API changes</h3>

<p>To support new services, core Libcloud API had to be refactored. The library
now consists of three top-level modules:</p>

<ul>
  <li>libcloud.compute.* (everything related to the compute has been moved here)</li>
  <li>libcloud.storage.* (new place for the storage API)</li>
  <li>libcloud.loadbalancer.* (new place for the load-balancer API)</li>
</ul>

<p>Importing stuff from the old location (e.g. from libcloud.providers import
get_driver) should still work, but you will receive a deprecation warning.</p>

<p>You are encouraged to update your code to use the new module locations. The
old paths will be fully deprecated and removed in version 0.6.0.</p>

<h3 id="other-notable-changes">Other notable changes</h3>

<p>All the pricing data has been moved to a separate JSON file. This should
make updating pricing a lot easier.</p>

<p>For a full list of changes, please check the CHANGES file &lt;
https://github.com/apache/libcloud/blob/trunk/CHANGES&gt;.</p>

<h3 id="download">Download</h3>

<p>Libcloud 0.5.0 can be downloaded from
http://libcloud.apache.org/downloads.html or install it using pip - pip
install apache-libcloud</p>

<h3 id="documentation">Documentation</h3>

<p>For the API documentation, please refer to
https://libcloud.apache.org/apidocs/0.5.0/</p>

<p>For a real world example, check the example_{compute,storage,balancer}.py
files which are located in the root directory.</p>

<p>We have been pretty busy with this release so we currently don’t have any
articles about the new APIs on the website yet, but we will try to add them
this week.</p>

<h3 id="bugs--issues">Bugs / Issues</h3>

<p>If you find any bug or issue, please report it on our issue tracker (
https://issues.apache.org/jira/browse/LIBCLOUD).</p>

<p>Attaching an example or test which reproduces it would be ideal</p>

<p>Source: <a href="http://mail-archives.apache.org/mod_mbox/libcloud-dev/201105.mbox/%3CBANLkTi=LqBidHLHUwAJSAWSzd-qSpad+dA@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/02/15/libcloud-sprint-will-be-held-at-pycon-2011.html">Libcloud sprint will be held at PyCon 2011</a></h2>
  
  <span class="post-date-author">By Tomaz Muraus on Feb 15, 2011</span>

  <div class="post-content">
    <p>Libcloud sprint will be held at PyCon 2011 in Atlanta. For more information,
please refer to the <a href="http://mail-archives.apache.org/mod_mbox/incubator-libcloud/201102.mbox/%3CAANLkTimwn5Dm372VYZ4YVcgKQqbVVwxyo8=DMFtHoTwg@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/sprints.html" rel="tag">sprints</a>, <a href="/blog/tags/pycon.html" rel="tag">pycon</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2011/01/17/libcloud-0-4-2-released.html">Libcloud 0.4.2 released</a></h2>
  
  <span class="post-date-author">By Jerry Chen on Jan 17, 2011</span>

  <div class="post-content">
    <p>The Apache Software Foundation and the Apache Libcloud Project are
pleased to announce the release and immediate availability of version
0.4.2 of Apache Libcloud (“libcloud”).</p>

<p>Apache Libcloud is a pure python client library for interacting with
many of the popular cloud server providers. It was created to make it
easy for developers to build products that work between any of the
services that it supports.</p>

<p>Apache Libcloud is available for download from:
<a href="http://incubator.apache.org/libcloud/downloads.html">http://incubator.apache.org/libcloud/downloads.html</a>.</p>

<p>Major changes since the previous release:</p>

<ul>
  <li>New drivers for CloudSigma, Brightbox, Rackspace UK</li>
  <li>Improvements to deployment capabilities</li>
  <li>libcloud.security module for SSL certificate verification, see
http://wiki.apache.org/incubator/LibcloudSSL</li>
</ul>


  </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/release-announcement.html" rel="tag">release announcement</a>, <a href="/blog/tags/security-release.html" rel="tag">security release</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2010/10/12/libcloud-0-4-0-released.html">Libcloud 0.4.0 released</a></h2>
  
  <span class="post-date-author">By Paul Querna on Oct 12, 2010</span>

  <div class="post-content">
    <p>The Apache Software Foundation and the Apache Libcloud Project are pleased to
announce the release and immediate availability of version 0.4.0 of Apache
Libcloud (“libcloud”).</p>

<p>Apache Libcloud is a pure python client library for interacting with many of
the popular cloud server providers. It was created to make it easy for
developers to build products that work between any of the services that it
supports.</p>

<p>Apache Libcloud is available for download from:
<a href="http://incubator.apache.org/libcloud/downloads.html">http://incubator.apache.org/libcloud/downloads.html</a>.</p>

<p>Major changes since the previous release:</p>

<ul>
  <li>Removed dependency on Zope.Interface.</li>
  <li>New driver for ElasticHosts.</li>
  <li>Bug fixes and improvements for GoGrid, EC2, Linode, Slicehost, and
RimuHosting.</li>
</ul>

<p>See the CHANGES file for more details: 
<a href="https://svn.apache.org/repos/asf/incubator/libcloud/tags/0.4.0/CHANGES">https://svn.apache.org/repos/asf/incubator/libcloud/tags/0.4.0/CHANGES</a>.</p>

<p>Source: <a href="http://mail-archives.us.apache.org/mod_mbox/www-announce/201010.mbox/%3CAANLkTinqaKjPE-xJUgEdZibF0oeCiyHwCx0VRmC9F=UW@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2010/05/11/libcloud-0-3-1-released.html">Libcloud 0.3.1 released</a></h2>
  
  <span class="post-date-author">By Paul Querna on May 11, 2010</span>

  <div class="post-content">
    <p>The Apache Software Foundation and the Apache Libcloud Project are pleased to
announce the release and immediate availability of version 0.3.1 of Apache
Libcloud (“libcloud”).</p>

<p>Apache Libcloud is a pure python client library for interacting with many of
the popular cloud server providers. It was created to make it easy for
developers to build products that work between any of the services that it
supports.</p>

<p>Apache Libcloud is available for download from:
<a href="http://incubator.apache.org/libcloud/downloads.html">http://incubator.apache.org/libcloud/downloads.html</a>.</p>

<p>Major changes since the previous release:</p>

<ul>
  <li>New Drivers for Dreamhost, Eucalyptus, Enomaly ECP, IBM Developer
Cloud and SoftLayer.</li>
  <li>Added new deployment and bootstrap API.</li>
  <li>Added support for Amazon EC2 Asia Pacific (Singapore) Region</li>
  <li>Improved test coverage for all drivers.</li>
</ul>

<p>Source: <a href="http://mail-archives.us.apache.org/mod_mbox/www-announce/201005.mbox/%3CAANLkTilX0aWMhmdZWm-vCF3XjNaOQHrv7MWuj0ogNhRf@mail.gmail.com%3E">release announcement</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/release-announcement.html" rel="tag">release announcement</a></p>
    </div>
  </div>
</div>

  

  
    <div class="post">
  
    <h2 class="post-title"><a href="/blog/2010/02/02/libcloud-0-2-0-released.html">Libcloud 0.2.0 released</a></h2>
  
  <span class="post-date-author">By Paul Querna on Feb 02, 2010</span>

  <div class="post-content">
    <p>Libcloud 0.2.0 has been released.</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/release-announcement.html" rel="tag">release announcement</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>
