Talks on Stephen Finucane (Fin-oo-can)

Manage Your OpenStack Resources From Kubernetes With ORC

stephenfinucane@hotmail.com (Stephen Finucane) — Sat, 18 Oct 2025 00:00:00 +0000

This talk introduced OpenStack Resource Controller (ORC), a set of controllers that allows management of OpenStack resources using Kubernetes CRDs. It was delivered during OpenInfra Summit Europe in Paris in October 2025.

Managing OpenStack resources efficiently can be complex, especially when striving for cloud-native agility and GitOps workflows. In this talk, we’ll introduce the OpenStack Resource Controller (ORC), a powerful solution combining the benefits of Kubernetes Custom Resource Definitions (CRDs) and controllers with OpenStack’s rich and mature APIs and application ecosystem. We’ll explore ORC’s fundamental “raison d’être,” highlighting how it directly addresses common provisioning pain points many developers and operators face. We’ll compare ORC against “the competition”, exploring both its strengths and weaknesses. Discover its core goals, design philosophy, and how ORC simplifies the declarative management of your OpenStack infrastructure, enabling seamless resource orchestration for modern cloud-native applications.

More information is available on the OpenInfra Summit Europe 2025 website.

Steps Down the OpenAPI Path

stephenfinucane@hotmail.com (Stephen Finucane) — Sat, 18 Oct 2025 00:00:00 +0000

This talks was delivered during the OpenInfra Summit Europe in Paris in October 2025. It was a continuation of a talk I gave at the previous OpenInfra Summit and focused on the continued development of the OpenAPI effort over the intervening two OpenStack releases.

OpenStack has been on a journey towards implementing formal OpenAPI v3.1 API specifications for all services for a number of releases now. We have many goals - better understanding our APIs, improving our documentation, easing client and library development, etc. - and we are finally delivering on many of these. Come learn about the milestones we’ve reached to date, and the benefits we’re already seeing from these efforts, and our plans for the next . We’ll talk about the complexities of implementing common functionality across services with vastly different APIs and stacks, the cool/horrifying things we’ve (re)discovered about our APIs, and the oxidation of our clients. We’ll also demonstrate some of the fruits of our labours and discuss how you, as a user, deployer, or contributor, can get involved in the effort.

More information is available on the OpenInfra Summit Europe 2025 website.

API Contracts: Bringing OpenAPI and Typing to OpenStack

stephenfinucane@hotmail.com (Stephen Finucane) — Wed, 11 Sep 2024 00:00:00 +0000

This talk was delivered during the OpenInfra Summit Asia in Suwon in September 2024. It focused on two efforts currently underway in the OpenStack community, one to add OpenAPI schema generation to many services, and another to add type annotations to the SDK and OpenStackClient.

OpenStack’s APIs - of both RESTful and Python variety - have evolved organically over time. This has allowed them to grow and change as new use cases have arisen (and older ones died away), but this organic growth has resulted in a large amount of cruft, weird corner cases and bugs, and generally lots of undefined behaviour, all things commonly known as tech debt. While a lot has been done to reduce this tech debt - ranging from low-hanging fruit like improved docstrings and better unit test coverage to bigger efforts like the api-ref docs and functional API tests - we know from experience that there are a non-trivial number of latent issues just waiting to be triggered. Fortunately, the broader tech ecosystem has not stood still since OpenStack was first introduced in the early 2010s. Two technologies in particular promise to massively improve how we document and understand our APIs: OpenAPI and Python type annotations. OpenAPI promises to provide a machine-readable definition of the various APIs, while Python type annotations allow us a way to provide guarantees about type information that were not previously possible in Python. In this talk, we will explore the work that has been ongoing to integrate both technologies into projects across OpenStack, how you as a user or developer can taking advantage of them, and how you can get involved.

More information is available on the OpenInfra Summit Asia 2024 website.

Zero-Downtime Upgrades With SQLAlchemy and Alembic

stephenfinucane@hotmail.com (Stephen Finucane) — Sun, 13 Nov 2022 00:00:00 +0000

This talk was delivered at PyCon Ireland 2022. As the name would suggest, I aimed to describe how to implement a database upgrade pattern using SQLAlchemy + Alembic that would allow you to evolve you database schema without incurring downtime.

Alembic is a database migrations tool written by the author of SQLAlchemy. Alembic is easy to get started with an provides a number of sensible defaults out-of-the-box. However, like SQLAlchemy itself, when you look under the hood you find a seriously capable engine capable of powering all sorts of database schema migrations. It can even auto-generate the migration files themselves!

In this presentation, we seek to explore some of these advanced features by implementing a pattern - the expand-contract pattern - that can allow for near zero-downtime database upgrades.

More information is available on the Python Ireland website.

Openstack From 10000ft

stephenfinucane@hotmail.com (Stephen Finucane) — Sat, 12 Nov 2022 00:00:00 +0000

This talk was a lightning talk I gave at PyCon Ireland 2022. There’s no real abstract.

Teaching Padawans to Chop Wood and Carry Water in Their Open Source Journey

stephenfinucane@hotmail.com (Stephen Finucane) — Tue, 14 Jun 2022 00:00:00 +0000

This talk was delivered during the OpenInfra Summit 2022 in Berlin. The aim was to provide some background on the mentoring activities happening in the OpenStack community and provide some advice for potential mentors and mentees on how to get involved in and run a successful mentorship.

Maintainers of most open source projects long for everlasting engagement from their contributors. Community-driven projects stand a better chance at this, provided the community itself is well-fed with new contributors and fresh ideas. Contributors may begin their journey with many motivations, however staying and taking on maintenance responsibilities is aided by the community’s culture and willingness to mentor. We began building engagement for the OpenStack Manila community years ago with one-on-one mentoring of new contributors. We scouted for interested folk at events, conducted hands-on workshops and continuously improved our on-boarding documentation. Our methods constantly changed with feedback from mentees. After mentoring nearly two dozen Outreachy, GSOC and college interns from across the world, we want to share our process and learnings through this presentation.

More information is available on the Eventbrite website.

What Is Nova?

stephenfinucane@hotmail.com (Stephen Finucane) — Wed, 10 Jun 2020 00:00:00 +0000

This talk was delivered to a number of Red Hat interns at the start of their internship and served as a brief, high-level overview of the OpenStack Compute (nova) project. On the day, it was bookended by an intro to OpenStack itself and an intro to the OpenStack Networking (neutron) project. There isn’t really a bio of note to share 🤷

A Documentation Driven Approach to Building APIs

stephenfinucane@hotmail.com (Stephen Finucane) — Wed, 13 May 2020 00:00:00 +0000

This talk was delivered during a Python virtual meetup. The aim was to introduce Django REST Framework and OpenAPI, in order to demonstrate how they could be combined to produce a well-tested, well-documented RESTful API.

Django REST Framework (DRF) does for REST APIs what Django does for web applications more generally. That is, it provides a powerful, flexible framework to help quickly building applications. OpenAPI (formerly Swagger) provides a machine-readable schema for describing the REST APIs made possible by the likes of DRF. When combined, they allow you to do some pretty neat things, which we’re going to cover in this talk.

Automatic generation of schemas from your API

Validation of APIs using schemas

Documentation!

The competition

Let’s see if OpenAPI really is the one API schema to rule them all…or something like that.

More information is available on the Meetup website.

A Lion, A Head, and A Dash of YAML

stephenfinucane@hotmail.com (Stephen Finucane) — Sat, 29 Feb 2020 00:00:00 +0000

This talk, delivered at PyCon Limerick 2020, was a repeat of a talk I’d previously given at FOSDEM 2018. Once again, this talk provided a quick dive into the somewhat complicated world of Sphinx extensions.

If you’ve read documentation for a Python library, you’ve almost certainly seen the end product of a docutils or Sphinx-powered documentation toolchain. Sphinx builds upon docutils and together, they provide the tool of choice for a majority of projects across the Python ecosystem.

One of the great advantages of both tools is their inherent customisability and extensibility: not only can you customise the output of the tools, be that HTML, LaTeX or something else, but you can also write extensions that allow you to do things up to and including automatically generating documentation for you.

In this presentation, which is part talk, part workshop, we’ll look at the basics for building and using your own extension for these tools, with the goal of solving the kinds of issues that have been seen in large Python-first communities like OpenStack. Some prior Python experience will be necessary, but no Sphinx or docutils experience is assumed.

More information is available on the PyCon Limerick 2020 website.

Will Someone Please Tell Me Whats Going On? (Redux)

stephenfinucane@hotmail.com (Stephen Finucane) — Sat, 01 Feb 2020 00:00:00 +0000

This was a talk I gave at FOSDEM 2020. I had previously given this talk at PyCon Limerick. The summary is repeated below.

Software rarely stands still (unless it’s TeX). Things are added, things are removed, things break and are then hopefully fixed. Managing this, from both the developer and user perspective, can be tough. In this talk we examine and compare some of the tools that one can use to make this process easier, such as ‘debtcollector’, ‘reno’ and ’towncrier’, and contrast these with alternatives used in other projects.

This talk would mainly be of interest to developers of open source libraries, though the same tooling can be used for any Python library or application that wishes to maintain stable interfaces and/or document changes in their product.

More information is available on the FOSDEM 2020 website.

Trading Flexibility for Performance: The HPC Story in OpenStack

stephenfinucane@hotmail.com (Stephen Finucane) — Mon, 27 May 2019 00:00:00 +0000

This lightning talk was presented at OpenStack Days CERN in May 2019. It gave an overview of the state of the art for HPC and NFV in the OpenStack Compute. The talk focused on three of the most important and complex NFV/HPC features in nova - CPU pinning, NUMA awareness and real-time - and detailed what they were, why they existed, and how we were trying to make them better.

Working With Documentation, The Openstack Way

stephenfinucane@hotmail.com (Stephen Finucane) — Tue, 30 Apr 2019 00:00:00 +0000

This talk was co-presented with Alex Settle at the Denver OpenStack Summit in April 2019. It serves as a brief history of documentation within OpenStack along with a how-to on contributing to documentation today.

Back in the old days, OpenStack’s documentation was managed by a central team and written in the unspeakable horror that is DocBook. Things have changed a lot since then, with documentation now spread out across multiple projects and Sphinx the documentation tool du jour. This presents a lot of opportunities for people, be they long-term contributors or novices, to make a real impact to OpenStack’s documentation. In this talk, we detail how one can get started contributing in this area, be it through writing your own guides, using Sphinx to automatically generate docs or simply fixing a typo. Viva la documentation!

More information is available on the OpenStack Summit website.

Will Somebody Please Tell Me What Is Going On?

stephenfinucane@hotmail.com (Stephen Finucane) — Sat, 23 Mar 2019 00:00:00 +0000

This was a talk I gave at the inaugural PyCon Limerick in March 2019. I explored some tools available within the Python ecosystem that can be used to manage change. Naturally, many of these were tools developed and used within OpenStack but I looked at other options to help present a more complete picture (hint: the OpenStack tools were all more mature, IMO).

Software rarely stands still (unless it’s TeX). Things are added, things are removed, things break and are then hopefully fixed. Managing this, from both the developer and user perspective, can be tough. In this talk we examine and compare some of the tools that one can use to make this process easier, such as ‘debtcollector’, ‘reno’ and ’towncrier’, and contrast these with alternatives used in other projects.

This talk would mainly be of interest to developers of open source libraries, though the same tooling can be used for any Python library or application that wishes to maintain stable interfaces and/or document changes in their product.

More information is available on the PyCon Limerick website.

Who Needs pandoc When You Have Sphinx?

stephenfinucane@hotmail.com (Stephen Finucane) — Sat, 02 Feb 2019 00:00:00 +0000

This was a talk I gave at FOSDEM 2019. In this talk, subtitled “An exploration of the parsers and builders of the Sphinx documentation tool”, I explored some of the less well known aspects of both Sphinx and docutils.

Using Sphinx doesn’t necessarily mean using reStructuredText for input and HTML for output. We explore Sphinx’s newfound support for Markdown as well as it’s broad range output formats available, before moving onto an overview of how you can develop your parser and builder extensions.

Sphinx is the documentation tool of choice for an increasing amount of projects, both inside and outside Python. Thanks to the success of platforms like Read the Docs, building documentation with this toolkit has never been easier. Most people associate Sphinx with the reStructuredText syntax provided by docutils, and typically output documents to HTML and, occasionally, PDF. However, Sphinx is capable of so much more. Since Sphinx 1.8, it is possible to use source documents written in the CommonMark syntax, while the amount of builders provided both in-tree and out-of-tree continue to grow.

Through this talk, we explore how one can build their documentation using Sphinx and Markdown source documents. We detail the variety of builders available as part of the standard Sphinx installation and as third-party extensions, including some basic configuration tips for the more commonly useful ones like man pages and LaTeX/PDF. Finally, we provide a high-level overview on how you can go about writing your own extensions to parse other plain-text documentation formats and output in additional documentation format. The latter of these will touch on docutils, a foundational component of Sphinx, so one can understand the intermediate documentation model it provides.

Full information is available on the FOSDEM website.

How to Double* the Performance of vSwitch-based Deployments

stephenfinucane@hotmail.com (Stephen Finucane) — Tue, 13 Nov 2018 00:00:00 +0000

This was a talk I have at the OpenStack Summit Berlin in November 2018. In this talk, I discussed the NUMA-aware vSwitches feature recently added to OpenStack Nova, explaining what it was, why you’d want it and how you could use it.

vSwitch solutions, such as DPDK-accelerated Open vSwitch, promise to provide much of the performance of SR-IOV with increased flexibility and decreased operational cost. However, while the switch may be virtual, the hardware that the vSwitch and VMs are running on is not. Unlike SR-IOV, NUMA affinity was not accounted for when instances using vSwitch-backed networking. This could result in a loss of up to 50% of network performance.

This changes in Rocky. With the completion of the NUMA-aware vSwitch feature, nova now has the ability to schedule and create you instances in a manner that will deliver the maximum possible performance from your vSwitch-powered network. Come learn how we did it and how you can start using this new functionality in your own deployments.

What can I expect to learn?

How NUMA can adversely affect the performance of your vSwitch-based deployment

What features nova provides to eliminate this performance penalty and how you can use this functionality in your own deployments

The work ongoing to continue improving performance in this area and related areas

More information is available on the OpenStack Summit Berlin website.

The Wonders of NUMA

stephenfinucane@hotmail.com (Stephen Finucane) — Wed, 23 May 2018 00:00:00 +0000

This talk was presented at the OpenStack Summit in Vancouver in May 2018. It provided an in-depth summary of what NUMA is and why it matters so much for high-performance workloads. It was delivered as a lightning talk which, to be honest, wasn’t really sufficient for such a complicated area (at least in the context on NUMA within OpenStack) but the slides should provide a decent overview of the topic.

You select the best possible hardware for the job, you optimize the host OS to deliver the best performance ever seen by mankind, and you tweak your high-performance vSwitch to ensure nothing, nothing, could possibly stop you now. You rub your bloodshot eyes, run openstack server create and, well, things don’t look so rosy.

Welcome to the world of OpenStack on NUMA-based architectures, where one poor scheduling decision can result in drastic performance reductions. Thankfully, OpenStack realized this some time ago and has been doing many wonderful things since then to prevent this pain. In this talk, we shine a light on all things NUMA, from both a general and OpenStack-orientated perspective.

Coming out of this talk, you should know everything there is to know about NUMA in OpenStack and will be able to, one can hope, finally put those performance issues to bed and get some sleep.

What can I expect to learn?

The talk is multi-faceted, covering a breadth of topics from hardware design right up to user interaction with OpenStack deployments. We aim to cover:

What NUMA is and why it exists

How and to what extent NUMA can affect your OpenStack deployment, and the techniques we use under-the-hood to prevent any performance degradation

What you, as a user, can do to further optimize your instances’ performance

In addition, work continues on these features. We also take a look forward at some of the work we’re doing to further improve things:

Why OVS-DPDK doesn’t deliver on NUMA-based systems, and what we’re doing about it (*)

Why live migration with CPU pinning doesn’t work, and what we’re doing about it (*)

(*) If we haven’t already done something about it by now

More information is available on the OpenStack Summit Vancouver website.

A Lion, A Head, and A Dash of YAML

stephenfinucane@hotmail.com (Stephen Finucane) — Sun, 04 Feb 2018 00:00:00 +0000

This talk, delivered at FOSDEM 2018, provided a quick dive into the somewhat complicated world of Sphinx extensions. Sphinx is an incredibly powerful tool but, surprisingly for a documentation, suffers from poor quality documentation. This talk aimed to fill in some of the blanks for users that aren’t so familiar with the tool and its inner workings.

The Sphinx documentation tool provides tremendous extensibility and theming options; options which are massively underutilized. We demonstrate how you can go about writing your own extensions and themes for Sphinx and ultimately how you treat your docs like code.

If you work in open source, then it’s increasingly likely that you’ve come across the Sphinx documentation tool. Originally written by and for the Python community, the past few years have seen an increasingly rapid adoption by non-Python projects. Recent adopters of Sphinx include the Linux kernel, Open vSwitch and the Dataplane Development Kit (DPDK), while other projects such as QEMU are preparing plans to migrate. Meanwhile, the Python ecosystem itself has only grown in strength and communities such as OpenStack have adopted the tool and have made extensive use of it.

Unfortunately, despite the widespread adoption and existence of multiple extensions, Sphinx is not always a very well understood tool. Extensions provide a pathway to greater functionality, for example, automatically generating documentation or generating docs in different output formats. Themes, meanwhile, provide a way to give a consistent, project-focused feel to your docs. The OpenStack community makes significant use of these extensibility features, which allow us to solve a number of problems in an automated manner.

How can I avoid documenting a command line application twice: once in code and once in my docs?

How can I take a large dataset and automatically convert this into multiple human-readable documents?

How can I move documents about without breaking links?

How can I automatically spell-check my documents?

How can I style my docs to match my project website?

Through this talk we will demonstrate how each of the above problems, and how many more, can be solved in an easy and automated manner through the power of Sphinx extensions and themes. We also demonstrate how you can share your extensions and themes with the world, if you’re so inclined

More information is available on the FOSDEM website.

Keeping It Real(Time)

stephenfinucane@hotmail.com (Stephen Finucane) — Sat, 03 Feb 2018 00:00:00 +0000

This talk was an expanded version of the talk I had given previously at the Sydney OpenStack Summit and, as then, I once again discussed the real-time capabilities of OpenStack Nova. It was delivered at FOSDEM 2018 to a crowd of Virtualization and IaaS enthusiasts.

Real-time in OpenStack is a thing now. Let’s explore what this actually looks like to a user, and (in brief) how it works under the hood.

Since Juno, OpenStack projects like nova have been on a steady march towards adding the features and capabilities that users with NFV and HPC workloads really need from their cloud. The latest of these nova features builds upon earlier work to finally make real-time workloads in an OpenStack cloud a reality. In this talk, we take a peek under the nova hood to see how this feature works and how it ties into earlier work in this area (hint: KVM + libvirt do most of the heavy lifting). We then demonstrate why this matters and how you can use this feature and others like it in your own applications.

More information is available on the FOSDEM website.

(note: I can’t find the original cover photo, sadly. If anyone locates the source, please let me know)

Keeping It Real(Time)

stephenfinucane@hotmail.com (Stephen Finucane) — Mon, 06 Nov 2017 00:00:00 +0000

Update: An expanded version of this talk was delivered at FOSDEM 2018 and is well worth the read if you’re interested in this.

This talk was given as a lightning talk at the OpenStack Summit in Sydney in November 2017. It focused on the new-found ability of OpenStack Nova to schedule real-time instances.

Ever get the feeling your cloud is just a bit too…cloudy? The flexibility and resource utilization that the cloud can offer might seem fantastic at first, but things look a little less rosy when you start thinking about the performance impacts the cloud can have on your applications, right?

Never fear: the OpenStack community hears you and and since Juno, projects like Nova have been on a steady march towards adding the features and capabilities that users with NFV and HPC workloads really need from their cloud. The latest of these Nova features builds upon earlier work to finally make real-time workloads in an OpenStack cloud a reality. In this talk, we take a peek under the Nova hood to see how this feature works and how it ties into earlier work in this area. We then demonstrate why this matters and how you can use this feature and others like it in your own applications.

What can I expect to learn?

This talk is mainly targeted towards attendees working in the Telco/NFV and HPC markets. These attendees are expected to learn about the real time features recently added to OpenStack Nova. In addition, these features build upon many existing features and we will cover some of these as part of the talk.

By the end of the talk, we would hope that attendees will have vastly expanded their knowledge of OpenStack Nova’s NFV/HPC capabilities, and would be able to use their knowledge of these capabilities in their own applications.

More information is available on the OpenStack Summit Sydney website.

Mailing List, Meet CI

stephenfinucane@hotmail.com (Stephen Finucane) — Sun, 05 Feb 2017 00:00:00 +0000

This talk was presented as a lightning talk at FOSDEM 2017. It described the CI features provided in Patchwork 2.0, which was at the time unreleased. I wrote a blog post to accompany the talk which is well worth reading (updated since to reflect changes in Patchwork 2.0 final).

What does it take to implement continuous integration-style automated testing into a mailing list-driven software project? Not a lot, actually. In this talk, we demonstrate how a simple but easily scaled testing system can be implemented for a such a project through the combination of Patchwork, the web-based patch tracking system, and open source CI tools such as Jenkins.

At FOSDEM 2016, developers working on Patchwork, the web-based patch tracking system, demonstrated some of the ongoing work in Patchwork. This work ranged from UI improvements to new features and APIs but, collectively, it had the goal of enabling automated testing functionality for software projects developed via mailing lists. The Patchwork developers have been busy since then and the application, in widespread use since 2008, recently hit the 2.0 milestone, marking this functionality as complete.

Projects such as the Dataplane Development Kit (DPDK) have quickly adopted the features that 2.0 brings, using them to enable real time, automated testing of patches sent to the mailing list. This automated testing provides a mechanism for developers to not only sidestep the more perfunctory of tasks, such as coding standard checks, but also to test changes in environments that they may not have at their disposal, such as differing hardware or OS configurations. As seen in projects pairing open source code collaboration tools like Gerrit or Rietveld with CI systems such as Jenkins or BuildBot, this continuous testing can provide huge improvements in developer velocity.

In this talk, we demonstrate how to build a basic “checkstyle” testing system through a combination of Patchwork and an off-the-shelf, open source CI system. This system will retrieve patches and dependencies, apply and test them, and report the results back to both Patchwork and a separate mailing list. This configuration demonstrates the best of Patchwork’s new features, and can be easily extended to cover far more complex testing scenarios.

Talks on Stephen Finucane (Fin-oo-can)

Manage Your OpenStack Resources From Kubernetes With ORC

Steps Down the OpenAPI Path

API Contracts: Bringing OpenAPI and Typing to OpenStack

Zero-Downtime Upgrades With SQLAlchemy and Alembic

Openstack From 10000ft

Teaching Padawans to Chop Wood and Carry Water in Their Open Source Journey

What Is Nova?

A Documentation Driven Approach to Building APIs

A Lion, A Head, and A Dash of YAML

Will Someone *Please* Tell Me Whats Going On? (Redux)

Trading Flexibility for Performance: The HPC Story in OpenStack

Working With Documentation, The Openstack Way

Will Somebody *Please* Tell Me What Is Going On?

Who Needs pandoc When You Have Sphinx?

How to Double* the Performance of vSwitch-based Deployments

The Wonders of NUMA

A Lion, A Head, and A Dash of YAML

Keeping It Real(Time)

Keeping It Real(Time)

Mailing List, Meet CI

Will Someone Please Tell Me Whats Going On? (Redux)

Will Somebody Please Tell Me What Is Going On?