Asyncio Python: асинхронний бекенд Повернутися до книгиДо книги

Зміст

Усе, що чекає на вас у книзі «Asyncio Python: асинхронний бекенд»:

Розділ 1. Перший асинхронний запит: побачити різницю на практиці

Створюємо невелику програму, яка виконує кілька мережевих операцій конкурентно, і порівнюємо її з послідовним виконанням. Розбираємо async def, await, asyncio.run та перші сценарії, у яких асинхронність справді виправдана.

Розробник готує кілька мережевих запитів одночасно.

Розділ 2. Event loop і корутини: що відбувається під капотом

З'ясовуємо, як цикл подій планує виконання корутин, коли передає керування та чому await не означає автоматичного запуску паралельної роботи. Розбираємо життєвий цикл корутини, Task, Future і типові причини блокування циклу подій.

Розробник наочно моделює роботу циклу подій і корутин.

Розділ 3. Коли завдань багато: Task, gather і TaskGroup

Вчимося запускати кілька операцій, збирати результати та керувати групами завдань. Порівнюємо asyncio.gather і TaskGroup, розглядаємо винятки, скасування та ситуації, коли дочірнє завдання не повинно залишитися без нагляду.

Розробник збирає результати кількох завдань в одну групу.

Розділ 4. Черга, яка не перевантажує систему

Будуємо конвеєр із виробників і споживачів за допомогою asyncio.Queue. Розглядаємо обмежену місткість, backpressure, обробку помилок, task_done та join, щоб черга допомагала керувати навантаженням, а не створювала нові проблеми.

Виробник і споживач працюють із чергою обмеженої місткості.

Розділ 5. Межі очікування: тайм-аути, скасування й помилки

Проєктуємо контрольоване завершення операцій, які зависають або виконуються довше за очікуване. Розбираємо asyncio.timeout, wait_for, CancelledError, семафори та сценарії коректного звільнення ресурсів.

Розробник контролює час операції та безпечно звільняє ресурси.

Розділ 6. Мережеві запити, які працюють разом

Створюємо асинхронний клієнт для взаємодії із зовнішніми API та розбираємо повторні спроби, обмеження частоти запитів, тайм-аути й обробку відповідей. Пояснюємо, чому звичайний requests не можна просто перетворити на неблокувальний виклик за допомогою await.

Розділ 7. База даних у ритмі асинхронності

Інтегруємо асинхронний доступ до даних із серверною логікою. На прикладах SQLAlchemy та MongoDB розглядаємо сесії, пул з'єднань, транзакції, конкурентні операції й типові проблеми синхронних драйверів у циклі подій.

Розділ 8. WebSocket і довготривалі з'єднання

Розробляємо асинхронний серверний сценарій із двостороннім обміном повідомленнями. Розглядаємо керування життєвим циклом з'єднань, конкурентну відправку, черги вихідних повідомлень, від'єднання клієнтів і контроль ресурсів.

Розділ 9. Коли asyncio недостатньо: потоки й процеси

Визначаємо, де закінчуються можливості асинхронного введення-виведення та починаються завдання, що потребують потоків або окремих процесів. Порівнюємо способи виконання блокувального й обчислювального коду, розглядаємо обмін даними та накладні витрати.

Розділ 10. Фонові завдання: від локальної черги до Celery

Переходимо від завдань усередині одного процесу до розподіленої фонової обробки. Будуємо архітектуру з Celery і брокером повідомлень, розбираємо воркери, маршрутизацію, повторне виконання, ідемпотентність та взаємодію з асинхронним бекендом.

Розділ 11. Асинхронність у продакшені: тести, спостережуваність і відмови

Перевіряємо конкурентний код у тестах, відтворюємо типові збої та шукаємо причини зависань, витоків завдань і виснаження пулів з'єднань. Розглядаємо логування, метрики, трасування, структуровану обробку помилок і контрольоване завершення застосунку.

Розділ 12. Масштабований асинхронний бекенд: від коду до архітектури

Об'єднуємо здобуті навички в архітектуру сервісу з асинхронними API, базами даних, WebSocket, фоновими воркерами та брокером повідомлень. Розглядаємо Docker, хмарне розгортання, DevOps-практики, навантажувальне тестування та інтеграцію ШІ-сервісів із контрольованими чергами й обмеженнями ресурсів.

Про цю книгу

Часом головна проблема асинхронного Python-коду не в повільній мережі, а в тому, що програма чекає на одну відповідь, хоча могла б у цей час виконувати іншу роботу. Ви додаєте `async` і `await`, але запити все одно гальмують, завдання накопичуються, а сервер несподівано вичерпує з'єднання. Саме тут починається різниця між простим використанням асинхронного синтаксису та грамотним проєктуванням асинхронної системи.

Книжка Антона Пилипенка адресована Python-розробникам, які переходять від послідовних скриптів до асинхронних API, мережевих сервісів і серверної архітектури, а також початківцям, готовим розібратися в механіці `asyncio`. Важлива відмінність: конкурентне виконання не означає паралельного. Кілька корутин можуть почергово використовувати один цикл подій, поки очікують на введення-виведення, але обчислення процесора від цього самі собою не прискорюються.

Ви навчитеся створювати контрольовані групи завдань, обмежувати кількість одночасних запитів, працювати з асинхронними базами даних і WebSocket, а також переносити тривалу фонову обробку до Celery. Окрему увагу приділено тому, що зазвичай виявляється вже в продакшені: скасуванню операцій, витокам ресурсів, повторним спробам, ідемпотентності та діагностиці зависань. Результатом стане не просто набір знайомих конструкцій Python, а розуміння того, як побудувати сервер, у якому кожне завдання має визначений життєвий цикл.

ПОТІК асинхронності: п’ять кроків від першої корутини до розподілених воркерів

Методика ПОТІК проводить вас від першої корутини до архітектури, здатної працювати з контрольованим навантаженням. Кожен наступний крок розширює попередній: спочатку ви розумієте механіку, потім організовуєте виконання, а далі вчитеся керувати системою.

  • Почати з корутин і зрозуміти, як працює цикл подій — розберіться з `async def`, `await`, життєвим циклом корутини та циклом подій. Навчіться відрізняти справжнє асинхронне очікування від блокувальної операції, яка зупиняє роботу всього циклу.
  • Організувати конкурентне виконання через Task, gather та TaskGroup — запускайте незалежні операції, збирайте результати й керуйте групами завдань. Порівняйте обробку винятків і скасування в `asyncio.gather` та `TaskGroup`, щоб дочірні операції не залишалися без нагляду.
  • Тримати під контролем ресурси, тайм-аути, помилки й скасування — обмежуйте конкурентність, установлюйте час очікування та звільняйте ресурси незалежно від результату операції. Налаштовуйте повторні спроби з обмеженою кількістю, затримкою та максимальним інтервалом.
  • Інтегрувати асинхронні компоненти, бази даних та мережеві сервіси — поєднуйте зовнішні API, асинхронні драйвери, транзакції, пули з'єднань і довготривалі з'єднання. Враховуйте межі кожного компонента, щоб синхронна операція не блокувала цикл подій.
  • Керувати фоновими завданнями, чергами й розподіленими воркерами — відокремлюйте локальну конкурентну роботу від розподіленої обробки через Celery та брокер повідомлень. Проєктуйте повторне виконання, ідемпотентність і відновлення після відмов без розрахунку на гарантоване виконання рівно один раз.

Перший крок без зайвої магії: перевірте, де ваш Python чекає даремно

Перш ніж переписувати застосунок на `asyncio`, перевірте, чи справді його робота обмежена очікуванням. За 10–15 хвилин ви зможете розібрати невеликий фрагмент власного коду, знайти потенційні місця блокування та скласти конкретну схему майбутнього асинхронного сценарію.

Для вправи знадобляться:

  • Python 3.11 або новіший;
  • звичайний редактор коду;
  • будь-який знайомий вам Python-сценарій, у якому є мережеві запити, читання файлів або звернення до зовнішніх сервісів.
Python-розробник працює над асинхронним бекендом

Не потрібно одразу встановлювати Celery, налаштовувати брокер повідомлень чи створювати сервер. Спочатку знайдіть роботу, яку справді варто організувати асинхронно.

Крок 1. Знайдіть місце, де програма чекає (2 хвилини).

Відкрийте знайомий Python-файл і знайдіть виклики, які можуть чекати на зовнішній результат. Це можуть бути HTTP-запити, звернення до бази даних, читання файлів або отримання відповіді від іншого сервісу.

Позначте кожен такий виклик коментарем `# WAIT`. Наприклад:

```python

import requests

def get_user(user_id):

response = requests.get(

f"https://example.com/users/{user_id}"

)

return response.json

```

У цьому прикладі програма чекає на відповідь HTTP-сервера. Виклик `requests.get` синхронний: поки відповідь не надійде, поточний потік не переходить до наступної інструкції.

Позначте цей рядок:

```python

response = requests.get(...) # WAIT

```

Важливо: очікування саме собою ще не означає, що операцію потрібно переписувати. Спочатку з'ясуйте, скільки таких операцій виконується і чи можуть вони бути незалежними.

Крок 2. Відокремте очікування від обчислень (2 хвилини).

Перегляньте позначені ділянки та розділіть їх на дві категорії:

  • I/O-bound — мережа, база даних, файлові операції, очікування зовнішніх відповідей.
  • CPU-bound — обчислення, обробка великих масивів даних, складні перетворення та інші операції, які активно використовують процесор.

Наприклад, отримання JSON через HTTP — це переважно I/O-bound операція. А складний розрахунок на основі вже отриманого JSON може бути CPU-bound.

Перевірка очікування мережевих запитів у Python

Додайте до відповідних ділянок коментарі:

```python

response = requests.get(url)

result = calculate_statistics(response.json)

```

Не намагайтеся зробити весь цей код асинхронним одним рухом. Асинхронне введення-виведення та обчислення потребують різних підходів: перше можна організувати через `asyncio`, друге за потреби винести в потік або окремий процес.

Крок 3. Перевірте асинхронні межі (3 хвилини).

Тепер з'ясуйте, чи підтримують ваші мережеві й файлові бібліотеки асинхронний інтерфейс.

Порівняйте два виклики:

```python

response = requests.get(url)

```

і

```python

response = await client.get(url)

```

Другий приклад показує форму асинхронного виклику, якщо `client` надає відповідний асинхронний метод. Саме слово `await` не перетворює синхронну функцію на асинхронну.

Перевірте документацію бібліотек, які використовує ваш застосунок. Знайдіть асинхронні аналоги мережевих і файлових операцій, якщо вони потрібні. Окремо позначте синхронні виклики, які поки що залишаються в коді.

Для кожного з них має бути зрозуміло, чи допустимо виконувати його в циклі подій, чи потрібен інший спосіб запуску.

Крок 4. Намалюйте шлях одного запиту (3 хвилини).

Візьміть один типовий запит до вашого майбутнього або наявного API. Розташуйте його основні компоненти в послідовності:

Обмеження кількості одночасних асинхронних завдань

```text

Клієнт

v

API-сервер

v

База даних

v

Зовнішній API

v

Відповідь клієнту

```

Тепер біля кожного переходу поставте позначку:

  • `WAIT` — програма очікує на зовнішню відповідь;
  • `CPU` — виконується обчислення;
  • `BLOCK` — потенційно блокувальна операція.

Наприклад, якщо сервер отримує дані з бази, а потім звертається до незалежного зовнішнього API, обидві операції можуть бути кандидатами на конкурентне виконання. Але якщо друга операція потребує результату першої, запускати їх одночасно немає сенсу.

Схема має показувати не просто перелік компонентів, а залежності між ними. Це допоможе не створювати конкурентність там, де її фактично немає.

Крок 5. Визначте межі конкурентності (2 хвилини).

Знайдіть дві незалежні операції, які не залежать одна від одної. Наприклад, отримання профілю користувача та завантаження загальнодоступного каталогу.

Позначте їх як кандидатів на конкурентне виконання:

```text

Запит до API

+---- Отримати профіль

+---- Завантажити каталог

v

Об'єднати результати

```

Після цього визначте, що обмежуватиме кількість одночасних операцій.

  • `Semaphore` — обмежить кількість операцій, які виконуються одночасно.
  • `Queue` — допоможе організувати передачу завдань між виробниками та споживачами.
  • `connection pool` — контролюватиме використання з'єднань із базою даних.

Не встановлюйте необмежену конкурентність. Якщо незалежних запитів тисячі, це не означає, що всі вони повинні одночасно звертатися до зовнішнього сервісу.

Моніторинг роботи розподілених фонових завдань

Крок 6. Визначте умови надійного завершення (2 хвилини).

Поверніться до позначених операцій і для кожної перевірте три ситуації:

  1. Тайм-аут: що відбудеться, якщо зовнішній сервіс не відповість вчасно?
  2. Помилка: як програма обробить недоступність сервісу або невдалий запит?
  3. Скасування: хто відповідатиме за завершення завдання та звільнення ресурсів?

Для повторних спроб передбачте обмежену кількість повторів, затримку між ними й максимальний інтервал. Для операцій, які можуть повторно змінювати дані, перевірте ідемпотентність.

У підсумку у вас буде невелика, але цілком практична схема: знайдені місця очікування, розділені типи навантаження, перевірені асинхронні межі, незалежні операції та правила завершення. Це вже не абстрактне знайомство з `asyncio`, а технічне завдання для першого асинхронного сценарію.

Що далі

У повній книзі кожен із цих кроків перетвориться на робочий код: від першої корутини та `TaskGroup` до черг, асинхронних транзакцій, WebSocket і Celery. Ви побачите, як окремі механізми взаємодіють у серверній системі, де потрібно обмежувати навантаження, як перевіряти поведінку під час збоїв і чому спостережуваність важлива не менше за швидкість відповіді. Приклади супроводжуватимуться розбором коду, архітектурними схемами, практиками й типовими помилками, щоб рішення можна було перенести у власний проєкт, а не просто повторити в навчальному середовищі.

Далі на вас чекає повний шлях від розуміння циклу подій до проєктування бекенду, який уміє керувати навантаженням, переживати збої та масштабуватися без втрати контролю над завданнями.

Для наступної редактури що важливіше: технічна глибина чи сильніший продажний вступ?

Це безкоштовний уривок. Повна книга — на сторінці книги.

MiravaMirava
Електронні книги →

Зміст

Вигляд

‹
›
↩ Продовжити читання