Going from 7,000 concurrent users to 50,000 concurrent users in a matter of seconds is not an uncommon occurrence at Kumparan. In this 5-10 minutes talk I will show you how Kumparan use Python asyncio to build a service to handle requests at this scale. Transcript: https://medium.com/@pyk/asynchronous-python-at-kumparan-a511d478c2b9

1. Bayu Aldi Yansyah
Data at Kumparan
github.com/pyk
PyCon Indonesia
November 3-4, 2018
Kalbis Institute, Jakarta
Asynchronous Python at Kumparan
x

2. The basics:
1. Coroutine is a function that has many entry points for
suspending and resuming the execution.
2. Task is used to schedule Coroutines to run concurrently.
3. Event Loop is Coroutine(s) and Task(s) runner.
Asynchronous Programming in Python
# Python 3.5+
import asyncio
Event Loop
Task
Coroutine

3. Event Loop
import asyncio
# Create new event loop
loop = asyncio.new_event_loop()
# Get the current event loop
loop = asyncio.get_event_loop()

4. async def process(input: str) -> str:
# time.sleep(5)
await asyncio.sleep(5)
return “Processed: {}”.format(input)
Coroutine
Example of entrypoint where Event Loop
can suspend or resume the execution.
# process(“test”)
loop.run_until_complete(process("test"))
loop.close()
Define Coroutine using async def
keyword
You should not call function that block
the main thread inside a Coroutine.
Coroutine cannot run on itself, it
depends on Event Loop.
You can call other Coroutine using
await keyword.

5. Task
from typing import None
def callback(future: asyncio.Future) -> None:
processed = future.result()
print(“{} is here”.format(processed))
async def main() -> None:
task1 = asyncio.create_task(process(“input 1”))
task2 = asyncio.create_task(process(“input 2”))
task1.add_done_callback(callback)
task2.add_done_callback(callback)
await asyncio.sleep(5)
loop.run_until_complete(main())
Wrap Coroutines using Task
to run them concurrently.
You can attach a callback
function

6. asyncio at Kumparan
asyncio is a perfect fit for high-performance web-servers, database connection libraries,
distributed task queues, etc.
List of services that we build on top of Python asyncio:
1. Tracker API
2. Tracker Transporter
3. A/B Test Splitter API
4. Trending Stories API
5. Personalized Feed API
6. And more ...

7. Use case: Tracking events receiver
Our goal is to be able to receive tracking events as many as possible. We implement
Fire-and-Forget approach on top of asyncio in order to reduce the response time.
# NOTE: Simplified version
async def track(request: Request) -> Response:
# ...
try:
# Fire
task = tracker.collect(event)
# ...
task.add_done_callback(callback)
# and Forget (Return the response immediately)
return api.success()
except ValueError as e:
return api.error(status_code=400, error=str(e))
except Exception as e:
error = "/v1/track failed"
return api.error(error=error, exception=e)
Coroutine.
Schedule another Coroutine with
event data as an input and wrap it
with asyncio.Task
Attach a callback

8. Use case: Tracking events receiver
With this implementation, we are able to achieve response time in less than 50ms.
.

9. Use case: Tracking events receiver
With this implementation, we are able to collect more than 10,000,000 tracking events on
daily basis.
Lion Air JT-610 Crash

10. Lessons Learned
1. The async library from the community is not mature yet, sometimes you
need to implement it by yourself.
2. It's easy to make mistake by calling a blocking function. There is no tool
that helps developers to spot this mistake.

11. Thanks!
Sounds Exciting?
Send your CV to joindev@kumparan.com