FastAPI Backend Development Bootcamp · Pelajaran

FastAPI dan Operasi Asinkron

Pahami cara FastAPI menangani fungsi asinkron secara alami dan cara menulis kode efisien yang tidak memblokir.

Pelajaran 2 dari 411 langkah

FastAPI dan Operasi Asinkron adalah pelajaran FastAPI Backend Development Bootcamp gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar FastAPI Backend Development Bootcamp, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus FastAPI Backend Development Bootcamp mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

FastAPI's Async Foundation

FastAPI is built for speed! It leverages Python's asynchronous features to handle many requests concurrently, especially I/O-bound tasks.

This means your API can stay responsive even when waiting for external resources like databases or other APIs.

Sync vs. Async Endpoints

In FastAPI, you can define two main types of endpoint functions:

Synchronous (def): These functions block the event loop while they run. If one request takes long, others might wait.
Asynchronous (async def): These functions can 'pause' and let other tasks run while they await an operation (like reading from a database), making your API non-blocking.

Simple Synchronous Endpoint

Here's a standard synchronous endpoint. While simple, if time.sleep() were a real, slow database call, it would block other requests until it completes.

Try running it and observe the delay if you try to make multiple requests quickly.

from fastapi import FastAPI
import uvicorn
import time

app = FastAPI()

@app.get("/sync_hello")
def sync_hello():
    time.sleep(2) # Simulate a blocking I/O operation
    return {"message": "Hello from sync endpoint!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Defining Asynchronous Endpoints

To make your endpoint non-blocking, use async def. This tells FastAPI (and Python) that this function can be suspended and resumed.

Inside an async def function, you use the await keyword to wait for other asynchronous operations to complete without blocking the entire application.

Your First Async Endpoint

This example uses asyncio.sleep(), which is an asynchronous sleep function. Notice the await keyword before it.

This allows FastAPI to handle other requests while this one 'sleeps', making the server more responsive.

from fastapi import FastAPI
import uvicorn
import asyncio

app = FastAPI()

@app.get("/async_hello")
async def async_hello():
    await asyncio.sleep(2) # Simulate non-blocking I/O
    return {"message": "Hello from async endpoint!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

When to Go Async

async def shines for I/O-bound operations. These are tasks that spend most of their time waiting for something else to happen, such as:

Making requests to external APIs (e.g., httpx).
Querying a database (e.g., asyncpg, SQLModel).
Reading/writing files from disk.
Network communication.

For CPU-bound tasks (heavy calculations), async def doesn't speed up the task itself, but it can help keep the server responsive.

Interacting with Async Libraries

When your FastAPI async def endpoint needs to interact with another asynchronous library (like an async HTTP client or an async database driver), you must use await.

Failing to use await will result in the awaitable object being returned directly, not its resolved result, which is usually not what you want!

Conceptual Async API Call

Imagine fetching data from another service. An async HTTP client allows this without blocking. Here's how it conceptually looks within an async def endpoint:

We simulate network latency with asyncio.sleep to show the non-blocking nature.

from fastapi import FastAPI
import uvicorn
import asyncio

app = FastAPI()

@app.get("/fetch_data")
async def fetch_external_data():
    # In a real app, you'd use an async HTTP client like 'httpx'
    # async with httpx.AsyncClient() as client:
    #     response = await client.get("https://api.example.com/data")
    #     data = response.json()

    await asyncio.sleep(1) # Simulate network latency
    return {"data": "Fetched async data!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Uvicorn: The Async Engine

FastAPI relies on an ASGI server like Uvicorn. Uvicorn is what actually runs your async def functions efficiently.

It manages the Python event loop, which orchestrates when different asynchronous tasks get to run.
When an await is encountered, Uvicorn can switch to another ready task, making your API highly concurrent.

This 'context switching' is what allows FastAPI to handle many requests without waiting for each one to finish entirely.

Quick Check: Async Use

You are building a FastAPI endpoint that needs to fetch data from a slow external API (an I/O-bound task). Which of the following is the best way to define this endpoint to ensure your FastAPI application remains responsive?

Jawab di pelajaran interaktif

Recap: Async FastAPI

We've explored how FastAPI harnesses Python's asynchronous features:

Use async def for endpoint functions that perform I/O-bound operations.
Use await when calling other asynchronous functions or libraries within an async def.
This non-blocking approach, powered by Uvicorn and the event loop, allows your FastAPI application to handle many concurrent requests efficiently, leading to highly responsive APIs.

Next, we'll look at how to offload truly long-running or CPU-bound tasks to background processes!

Gratis untuk memulai

Belajar FastAPI Backend Development Bootcamp dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 21
Pelajaran: 84

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “FastAPI dan Operasi Asinkron” gratis?

Ya — teks lengkap “FastAPI dan Operasi Asinkron” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus FastAPI Backend Development Bootcamp, upgrade ke CoddyKit PRO. Kursus FastAPI Backend Development Bootcamp mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “FastAPI dan Operasi Asinkron”?

Pahami cara FastAPI menangani fungsi asinkron secara alami dan cara menulis kode efisien yang tidak memblokir. Kamu berlatih FastAPI Backend Development Bootcamp dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai FastAPI Backend Development Bootcamp?

Tidak diperlukan pengalaman sebelumnya. FastAPI Backend Development Bootcamp di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “FastAPI dan Operasi Asinkron” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran FastAPI Backend Development Bootcamp ini?

Ya. Setiap pelajaran FastAPI Backend Development Bootcamp menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke FastAPI Backend Development Bootcamp