Gain insights into Python's scalability, concurrency, and distribution. Learn about CPU scaling, event loops, queue-based distribution, and building REST APIs to optimize and deploy high-performance applications.

python.tar.gz

Chapter2

Chapter7

Chapter5

Chapter6

Chapter3

Chapter7-without-etcd

Chapter8-with-etcd

Chapter9

Chapter9-gabbi

Chapter10-heroku

Chapter10-aws_eb

Chapter11_Tox_integration

Chapter11_Tox_integration-pifpaf

Chapter11_pifpaf_fixtures

Chapter12_caching

Chapter13_Performance

Chapter13_Performace_KCacheGrind

Chapter5-rq-dashboard

Chapter5-celery-flower

Chapter10-gcloud

Chapter2-zsh

Chapter13_Performace_KCacheGrind-copy

Chapter11_Tox_integration-pifpaf-postgresql

Celery-Project1_Sol

Celery-Project1_Sol2

Python, in all of its greatness, is often dismissed when needing to write performant and distributed applications. It’s considered to be slow and not suited for the task. In this course, you will find that with the right implementation of Python, you can write applications that scale horizontally, perform well, and are distributed. 

To kick things off, you’ll learn about CPU scaling, concurrency, and event loops, all of which are crucial for implementing a distributed system. After that, you’ll move on to queue-based distribution, lock management, and group memberships, which are fundamental concepts for maintaining availability and consistency in distributed applications.

In the last half, you’ll learn how to build a REST API, how to deploy your app to a PaaS, and how to optimize your application's performance.

By the end of this course, you’ll be more productive with Python, you’ll be able to write faster applications that are distributed, and you’ll have a great new skill that is highly coveted.

The Hacker's Guide to Scaling Python

The _Tooz_ library implements a common pattern that it calls ”group membership”. The pattern is quite easy to understand and is illustrated in the following figure.

# Group rules
Here are the rules: a group is a set containing zero or more members. When a node joins a group, it becomes a member of this group. A member can leave the group at any time: either on its own (shutdown) or because it did not renew membership. The membership tracking is automatically done by _Tooz_ and the backend it uses.

> **Note:** As discussed in the previous [chapter](https://www.educative.io/courses/hackers-guide-scaling-python/using-tooz-locking-abstraction), Tooz supports several backends including _memcached_ and _etcd_. The robustness of the membership and liveliness tracking depends on the integrity of the backend. Using a backend such as _ZooKeeper_ and its Paxos consensus algorithm is more robust than using a solo Redis instance. I invite you to look at the requirements and dig into all the features provided by backends supported by Tooz for more information.

> **Note:** You will need to start _etcd_ to make the example work.  Simply run `etcd` from the command line in a separate terminal (open new terminal using `+` button beside **Terminal** tabs) before running each example as instructed. If you do not have _etcd_, you can use _memcached_ instead. Replace the `etcd://localhost` URL with `memcached://localhost` in the code and run _memcached_ using command `memcached -u memcache` instead of _etcd_.

After running _etcd_ in a separate terminal you will see the output similar to the following:

Learn how to create, join, and leave groups in tooz library using Python.

Creating, Joining and Leaving Groups

Scaling

CPU Scaling

Event Loops

Functional Programming

Queue-Based Distribution

Designing for Failure

Create a Web Crawler

Project Walkthrough

Lock Management

Group Membership

REST Interfaces

Deploying on PaaS

Testing Distributed Systems

Caching

Performance

Conclusion

Creating, Joining and Leaving Groups

Group rules