Kem Intensif Pembangunan Bahagian Belakang FastAPI · Pelajaran

Melaksanakan Tugasan Latar Belakang

Pelajari cara memindahkan operasi yang mengambil masa panjang kepada tugasan latar belakang bagi mengelakkan API tersekat dan meningkatkan pengalaman pengguna.

Pelajaran 3 daripada 411 langkah

Melaksanakan Tugasan Latar Belakang ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Titik Akhir Perlahan dan UX

Bayangkan API Anda perlu melakukan sesuatu yang mengambil masa, seperti menghantar e-mel atau memproses fail besar, selepas menerima permintaan pengguna.

Jika API Anda menunggu tugas ini selesai sebelum memberikan respons, pengguna akan mengalami aplikasi yang perlahan dan tidak responsif. Ini dipanggil operasi menyekat.

Pengalaman pengguna yang buruk sering menyebabkan pengguna meninggalkan aplikasi Anda!

API Menyekat berbanding Tanpa Sekatan

Bayangkan situasinya seperti memesan makanan:

Menyekat: Anda membuat pesanan, dan pelayan menunggu makanan Anda dimasak, dihidangkan dan dimakan sebelum menerima pesanan seterusnya. (Layanan yang teruk!)
Tanpa sekatan: Anda membuat pesanan, pelayan menghantar pesanan Anda ke dapur dan terus mengambil pesanan pelanggan seterusnya. Makanan Anda disediakan di latar belakang.

Kita mahu API kita tidak menyekat supaya pengalaman pengguna menjadi lancar.

Memperkenalkan BackgroundTasks FastAPI

FastAPI menyediakan cara mudah untuk menjalankan operasi di 'latar belakang' selepas menghantar respons HTTP kepada klien. Hal ini dilakukan menggunakan kebergantungan BackgroundTasks.

BackgroundTasks membolehkan Anda menambahkan fungsi ke dalam senarai yang akan dilaksanakan setelah laluan API utama selesai dan respons telah dihantar.

Menyuntik BackgroundTasks

Untuk menggunakan tugas latar belakang, Anda hanya perlu mengisytiharkan parameter dengan jenis BackgroundTasks dalam fungsi operasi laluan Anda. FastAPI akan menyuntik satu tika daripadanya secara automatik.

Import BackgroundTasks daripada fastapi.
Isytiharkan parameter, contohnya background_tasks: BackgroundTasks.
Gunakan background_tasks.add_task() untuk menjadualkan fungsi.

Demo Tugas Latar Belakang Pertama

Mari kita lihat contoh asas. Tugas ini akan mencetak mesej selepas respons API dihantar. Ingat untuk menjalankan uvicorn main:app --reload.

from fastapi import FastAPI, BackgroundTasks
import time

app = FastAPI()

def write_notification(email: str, message=""):
    time.sleep(2) # Simulate a long operation
    with open("log.txt", mode="a") as email_file:
        email_file.write(f"notification for {email}: {message}\n")
    print(f"Notification written for {email}")

@app.post("/send-notification/{email}")
async def send_notification(email: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(write_notification, email, message="Welcome to CoddyKit!")
    return {"message": "Notification sent in background!"}

Memahami Aliran Pelaksanaan

Amat penting untuk memahami bila tugas latar belakang dilaksanakan:

Fungsi operasi laluan dijalankan.
Respons HTTP dihantar kembali kepada klien.
Kemudian, fungsi yang ditambahkan ke dalam BackgroundTasks dilaksanakan.

Ini bermakna klien tidak perlu menunggu tugas tersebut selesai, sekali gus meningkatkan prestasi yang dirasakan.

Menghantar Argumen kepada Tugas

Anda boleh menghantar sebarang argumen yang diperlukan oleh fungsi latar belakang Anda kepada add_task(). Argumen pertama ialah fungsi itu sendiri, diikuti oleh argumennya.

Argumen boleh berupa argumen kedudukan atau argumen kata kunci, sama seperti ketika memanggil fungsi Python biasa.

Contohnya: background_tasks.add_task(my_function, arg1, arg2=value).

Mensimulasikan Penghantaran E-mel

Satu senario lazim untuk tugasan latar belakang ialah menghantar e-mel. Proses ini boleh mengambil masa beberapa saat, yang akan menyebabkan pengguna anda menunggu jika dilakukan terus dalam laluan API.

Di sini, kami mensimulasikan penghantaran e-mel kepada beberapa penerima. Cuba jalankannya daripada antara muka /docs!

from fastapi import FastAPI, BackgroundTasks
import asyncio # For async sleep

app = FastAPI()

async def send_email_async(recipients: list, subject: str, body: str):
    print(f"Starting email send to {recipients}...")
    await asyncio.sleep(3) # Simulate network delay for sending email
    print(f"Email '{subject}' sent to {recipients} with body: '{body}'")

@app.post("/send-marketing-email/")
async def marketing_campaign(
    recipients: list[str],
    subject: str,
    body: str,
    background_tasks: BackgroundTasks
):
    # The actual email sending is offloaded
    background_tasks.add_task(send_email_async, recipients, subject, body)
    return {"message": "Marketing email campaign initiated in background!"}

Pertimbangan Penting

Walaupun berkuasa, BackgroundTasks bukan untuk semua perkara:

Jangka pendek: Paling sesuai untuk tugasan yang selesai dalam tempoh yang agak singkat (beberapa saat hingga beberapa minit).
Tiada penyimpanan: Jika proses FastAPI anda terhenti, tugasan yang dijadualkan akan hilang.
Tiada percubaan semula: Tugasan ini tidak mempunyai mekanisme percubaan semula terbina dalam untuk tugasan yang gagal.
Bukan untuk pengiraan berat: Untuk tugasan yang berjalan sangat lama, menggunakan CPU secara intensif atau memerlukan toleransi kerosakan, pertimbangkan baris gilir tugasan khusus seperti Celery, Redis Queue (RQ) atau yang serupa.

Semakan Tugasan Latar Belakang

Anda telah mempelajari penggunaan BackgroundTasks. Pernyataan manakah tentang BackgroundTasks FastAPI yang benar?

Jawab dalam pelajaran interaktif

Ulang Kaji: Tugasan Latar Belakang

Kami telah meneroka cara BackgroundTasks FastAPI membantu memastikan API anda terus responsif:

Tugasan ini berjalan selepas respons HTTP dihantar.
Tugasan ini amat sesuai untuk operasi yang tidak kritikal dan agak singkat seperti menghantar pemberitahuan.
Anda mengisytiharkannya sebagai kebergantungan dan menggunakan add_task().
Untuk tugasan yang benar-benar lama atau kritikal, pertimbangkan baris gilir tugasan luaran.

Dengan menggunakan tugasan latar belakang, anda memastikan pengalaman yang lebih lancar untuk pengguna API anda!

Percuma untuk bermula

Pelajari Kem Intensif Pembangunan Bahagian Belakang FastAPI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 21
Pelajaran: 84

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Melaksanakan Tugasan Latar Belakang” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “Melaksanakan Tugasan Latar Belakang”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Melaksanakan Tugasan Latar Belakang”?

Pelajari cara memindahkan operasi yang mengambil masa panjang kepada tugasan latar belakang bagi mengelakkan API tersekat dan meningkatkan pengalaman pengguna. Anda berlatih Kem Intensif Pembangunan Bahagian Belakang FastAPI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Bahagian Belakang FastAPI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Melaksanakan Tugasan Latar Belakang” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Kem Intensif Pembangunan Bahagian Belakang FastAPI