Floris Bruynooghe

Serverside applications are more and more likely to need to run in dynamic cloud environments where they can automatically scale as required. One rightfully popular approach is to run the application as a Docker container inside a Kubernetes cluster, giving you a lot of operational benefits thanks to the Kubernetes folks.

For the most part it is rather easy to make your Python application work inside a Docker container. But there are a number of common patterns one can follow to save time by delegating more things to the runtime environment. Furthermore you can start adding a few simple non-intrusive features to your application which will help improve the application live-cycle in the cluster, ensuring smooth hand-over when migrating the container to different nodes or scaling it up or down.

This talk will discuss how to write a Python application which will behave well in this environment, starting with the basics steps you can rely on the runtime for, covering logging and all the way to supporting the service life-cycle, health checking and monitoring in a Kubernetes environment. You will see that building a cloud-native application is not very hard and something you can gradually introduce.

One of Python's early and lasting strengths has been how easy it is to call into or wrap existing C libraries using extension modules. However, there are still many subtle details to take care off and it is all to easy to leak references or memory.

Over time additional mechanisms have been created, like SWIG, ctypes and Cython, all with their own barriers to entry, strong points and limitations. The most recent addition is the CFFI project from PyPy. This talk will try to cover what the limitations of various approaches are and how CFFI tries to address them. Also noting some possible stumbling blocks when chosing CFFI and pointing out where it falls short of it's promises.

py.test is a powerful and Pythonic unit testing tool which can scale from a few quick no-boilerplate tests to running huge unit and integration test suites.

One unique and powerful feature of py.test the dependency injection of test fixtures into the tests using function arguments. While the injection of fixtures via function arguments looks uncommon when used to the traditional JUnit setup and teardown mechanisms, py.test's fixtures are simple yet very flexible and arguably more powerful. This talk will walk through simple fixtures building up to show how to create more complicated setups by composing fixtures, controlling their scope and paremetrisation. This should lead to a good understanding of why fixtures are designed the way they are and why this is a very good and helpful mechanism to setup a test suite.