Pelanjutan Multi-Proses untuk mengoptimumkan Cache Memori Tinggi Fastapi: Amalan Senibina yang Didorong oleh Peristiwa

Artikel ini bertujuan untuk menyelesaikan masalah bahawa aplikasi FastAPI dalam mod pelbagai proses gunicorn telah meningkatkan penggunaan memori disebabkan oleh cache memori yang besar (seperti 8GB), menjadikannya sukar untuk memproses proses kerja dengan berkesan. Strategi teras adalah untuk mengadopsi seni bina yang didorong oleh peristiwa untuk mengimbangi tugas pemprosesan CPU dan pemprosesan data dari pelayan Web ke dalam mekanisme pemprosesan asynchronous bebas, dengan itu mencapai respons serentak yang tinggi terhadap perkhidmatan web, sambil mengoptimumkan penggunaan sumber memori dan meningkatkan kebolehkerjaan keseluruhan aplikasi.

Cabaran: Konflik antara cache memori yang tinggi dan sambungan pelbagai proses

Apabila aplikasi FastAPI mengandungi cache memori yang besar (mis. 8GB) dan berjalan melalui Gunicorn dalam mod Multi-Process untuk mengendalikan lebih banyak permintaan, terdapat cabaran teras: setiap pekerja Gunicorn adalah proses sistem operasi yang berasingan, dan mereka tidak berkongsi ingatan. Ini bermakna bahawa jika proses pekerja N dimulakan, setiap proses akan memuatkan salinan cache 8GB, mengakibatkan jumlah penggunaan memori sehingga 8GB * N. Sebagai contoh, menjalankan 4 proses pekerja akan memerlukan 32GB RAM, yang tidak dapat diterima untuk persekitaran yang terhad sumber dan mengehadkan dengan tegas skala aplikasi.

Dalam idea asal, penggunaan cache yang diedarkan (seperti Redis) dianggap berkongsi data, tetapi ini sering bermakna terdapat banyak pengubahsuaian kepada perpustakaan pihak ketiga yang sedia ada yang bergantung pada cache memori yang besar, meningkatkan kerumitan dan usaha pelaksanaan. Oleh itu, kita memerlukan penyelesaian yang lebih elegan dan kurang mengganggu.

Strategi Teras: Decoupling dan Pemprosesan Asynchronous

Amalan terbaik untuk menyelesaikan masalah di atas adalah menggunakan seni bina yang didorong oleh peristiwa , mengehadkan tanggungjawab teras pelayan web (aplikasi FastAPI) untuk menerima permintaan dan bertindak balas dengan cepat, sambil memakan masa yang memakan masa, intensif, atau memori pemprosesan data yang intensif ke dalam komponen pemprosesan bebas, asynchronous. Dengan cara ini, pelayan web boleh disimpan ringan dan hanya menggunakan sedikit memori, yang membolehkan lebih banyak proses pekerja Gunicorn mula mengendalikan permintaan serentak tanpa menyebabkan letupan memori.

Idea utama strategi ini adalah decoupling : decoupling permintaan penerimaan dari logik pemprosesan data sebenar. Apabila pelayan web menerima permintaan yang perlu memproses data besar, ia tidak segera melaksanakan pemprosesan, tetapi menerbitkan maklumat yang relevan mengenai pemprosesan permintaan (seperti ID tugas, data input, dll.) Ke barisan mesej atau giliran tugas, dan kemudian segera mengembalikan respons "diterima" atau "memproses" kepada pelanggan. Tugas -tugas ini kemudiannya dimakan dari barisan dan diproses oleh proses atau perkhidmatan pekerja latar belakang bebas.

Pelan pelaksanaan khusus

Berikut adalah beberapa penyelesaian yang berkesan untuk melaksanakan seni bina yang didorong oleh peristiwa dan menyahpasang tugas pemprosesan data:

1. Giliran tugas (seperti saderi)

Saderi adalah giliran tugas yang diedarkan dengan kuat yang sesuai untuk mengendalikan sejumlah besar tugas python yang memerlukan pelaksanaan tak segerak. Ia membolehkan aplikasi web menghantar tugas yang memakan masa kepada proses pekerja saderi bebas, sehingga tidak menyekat pelayan web.

Bagaimana ia berfungsi:

1. Pengeluar (Aplikasi Fastapi) : Selepas menerima permintaan itu, merangkum data tugas ke dalam tugas saderi dan hantar ke broker mesej (broker, seperti redis atau rabbitmq).
2. Broker Mesej : Kedai tugas yang belum selesai.
3. Pekerja Saderi : Proses bebas yang terus mendengarkan kepada broker mesej, memperoleh dan melaksanakan tugas.

Contoh kod (konseptual):

Pertama, pasang saderi dan broker mesejnya (seperti redis):

 Pip memasang saderi redis

Tentukan aplikasi dan tugas saderi (app/celery_app.py):

 dari saderi import saderi

# Konfigurasikan saderi, gunakan redis sebagai broker mesej dan hasil penyimpanan sadery_app = saderi (
    'my_fastapi_tasks',
    broker = 'redis: // localhost: 6379/0',
    backend = 'redis: // localhost: 6379/0'
)

# Tentukan tugas yang memakan masa simulasi yang mungkin memerlukan akses kepada data "cache" @celery_app.task
def process_huge_data_task (data_id: str):
    "" "
    Simulasi tugas yang memproses sejumlah besar data.
    Tugas ini akan dilaksanakan dalam proses berasingan oleh pekerja saderi.
    Jika anda perlu mengakses data yang dikongsi, anda boleh mempertimbangkan lulus ID data kepada pekerja.
    Pekerja kemudian diambil dari penyimpanan bebas pelayan web yang dikongsi bersama (seperti cache yang diedarkan atau pangkalan data).
    "" "
    cetak (f "pekerja saderi memproses data: {data_id}")
    # Menganggap bahawa ini adalah masa import logik untuk mengakses dan memproses data 8GB
    Time.Sleep (10) # Simulasi Operasi Operasi yang Memakan Masa = F "Data {Data_ID} pemprosesan selesai."
    cetak (hasil)
    Keputusan pulangan

Hubungi tugas (app/main.py) dalam aplikasi fastapi:

 Dari Fastapi Import Fastapi, Latar Belakang
dari app.celery_app import process_huge_data_task

app = fastapi ()

@app.get ("/process_data/{data_id}")
async def trigger_data_processing (data_id: str):
    # Hantar tugas memakan masa kepada pekerja saderi yang tidak disengajakan sebagai tugas pemprosesan = proses_huge_data_task.delay (data_id)
    # Mengembalikan respons dengan segera, termasuk ID tugas
    kembali {"Mesej": "Tugas pemprosesan data telah dikemukakan", "Task_id": Task.id}

@app.get ("/task_status/{task_id}")
async def get_task_status (tugas_id: str):
    tugas = proses_huge_data_task.asyncresult (tugas_id)
    jika tugas.ready ():
        kembali {"status": "lengkap", "hasil": task.result}
    elif tugas.pending:
        kembali {"status": "menunggu"}
    elif task.failed ():
        kembali {"status": "gagal", "ralat": str (task.result)}
    lain:
        kembali {"status": "sedang berjalan"}

menyebarkan:

1. Mulakan pelayan Redis.
2. Mulakan permohonan Fastapi (melalui Gunicorn): Gunicorn App.Main: App-Pekerja 4-Uvicorn.Workers.UvicornWorker kelas pekerja-mengikat 0.0.0.0:8000
3. Mula pekerja saderi: saderi -a app.celery_app worker --loglevel = info

Dalam mod ini, pelayan web boleh menjalankan pelbagai proses pekerja, masing -masing menduduki hanya sedikit memori, sementara pemprosesan data sebenar dilakukan oleh pekerja saderi bebas, yang boleh digunakan pada mesin dengan memori yang mencukupi seperti yang diperlukan dan boleh diperkatakan secara bebas.

2. Giliran Mesej (seperti Apache Kafka/Rabbitmq)

Apache Kafka atau Rabbitmq adalah broker pemesejan yang kuat untuk membina platform streaming acara rendah, rendah latensi atau sistem pemesejan yang boleh dipercayai. Mereka boleh berfungsi sebagai mekanisme decoupling yang lebih umum dan fleksibel.

Bagaimana ia berfungsi:

1. Pengeluar (Aplikasi Fastapi) : Menerbitkan permintaan pemprosesan data sebagai mesej kepada topik tertentu (Kafka) atau barisan (RabbitMQ).
2. Broker Mesej : Simpan dan mesej teruskan yang boleh dipercayai.
3. Pengguna (Perkhidmatan Bebas) : Satu atau lebih mikroservis bebas atau proses latar belakang melanggan dan mengambil mesej ini dan melaksanakan pemprosesan data.

Kelebihan:

• Output dan skalabiliti yang tinggi : dapat mengendalikan sejumlah besar mesej.
• Decoupling lebih teliti : pengeluar dan pengguna tahu sedikit tentang satu sama lain dan mudah dibangunkan, digunakan dan skala secara bebas.
• Kegigihan : Mesej boleh berterusan untuk memastikan mesej tidak hilang.

Contoh (konseptual): Fastapi sebagai pengeluar:

 dari fastapi import fastapi
# Katakan anda mempunyai pelanggan barisan mesej, contohnya untuk Kafka: Confluent-Kafka-Python
# dari pengeluar import confluent_kafka

app = fastapi ()
# producer = producer ({'bootstrap.servers': 'localhost: 9092'}) # Kafka Producer

@app.post ("/submit_analysis")
async def hantar_analysis (muatan: dict):
    # Menerbitkan permintaan analisis ke barisan mesej# producer.produce ('data_analysis_topic', nilai = json.dumps (muatan) .encode ('UTF-8')))
    # producer.flush ()
    cetak (f "permintaan analisis telah diposkan ke barisan mesej: {muatan}")
    kembali {"Mesej": "Permintaan analisis telah dikemukakan ke barisan"}

Perkhidmatan Pengguna Bebas:

 # Ini adalah perkhidmatan python mandiri yang berjalan pada proses atau pelayan lain # dari confluent_kafka pengguna import, kafkaexception

# pengguna = pengguna ({
# 'bootstrap.servers': 'localhost: 9092',
# 'kumpulan.id': 'my_analysis_group',
# 'auto.offset.reset': 'terawal'
#})
# consumer.subscribe (['data_analysis_topic'])

# sementara benar:
# msg = consumer.poll (timeout = 1.0)
# Sekiranya MSG tidak ada: Teruskan
# jika msg.error ():
# jika msg.error (). code () == kafkaexception._partition_eof:
# Teruskan
# lain:
# cetak (msg.error ())
#break
#     
# data_to_process = json.loads (msg.value (). decode ('utf-8'))
# cetak (f "pengguna memproses data: {data_to_process}")
# # Jalankan logik pemprosesan data intensif atau memori CPU di sini # # ...
# consumer.close ()

Pendekatan ini memerlukan penyelenggaraan individu broker mesej dan perkhidmatan pengguna, tetapi menyediakan fleksibiliti dan skalabiliti yang sangat tinggi.

3. Perkhidmatan Awan tanpa fungsi pelayan (seperti AWS Lambda)

Untuk aplikasi yang digunakan dalam persekitaran awan, perkhidmatan pengkomputeran tanpa pelayan dari penyedia awan (seperti AWS Lambda, Fungsi Azure, Fungsi Awan Google) boleh digunakan untuk menyahpasang tugas pemprosesan data.

Bagaimana ia berfungsi:

1. Aplikasi FastAPI (sebagai backend API Gateway) : Selepas menerima permintaan, ia mencetuskan fungsi tanpa pelayan melalui panggilan SDK atau API.
2. Fungsi tanpa pelayan : Platform awan melancarkan contoh fungsi yang diperlukan untuk melaksanakan logik pemprosesan data. Contoh fungsi boleh dilanjutkan secara bebas dan biasanya dikenakan berdasarkan penggunaan sumber pengkomputeran sebenar.

Kelebihan:

• Tiada pengurusan pelayan diperlukan : Platform awan bertanggungjawab untuk pengurusan dan skala pelayan yang mendasari.
• Bayar atas permintaan : Hanya membayar untuk masa berjalan sebenar fungsi, yang kos efektif.
• Pengembangan dan Penguncupan Elastik : Secara automatik berkembang dan mengecut mengikut beban.

Contoh (konseptual): Memanggil Lambda dalam aplikasi Fastapi:

 dari fastapi import fastapi
# Import Boto3 # AWS SDK untuk Python

app = fastapi ()
# lambda_client = boto3.client ('lambda', region_name = 'your-region')

@app.post ("/process_data_with_lambda")
async def process_data_with_lambda (muatan: dict):
    # Panggil AWS Lambda Fungsi untuk memproses data asynchronously# response = lambda_client.invoke (
    # FunctionName = 'Data-Data-Processing-Lambda',
    # InvocationType = 'Event', # Panggilan Asynchronous # muatan = json.dumps (muatan)
    #)
    cetak (f "permintaan pemprosesan data telah dihantar ke lambda: {muatan}")
    kembali {"mesej": "tugas pemprosesan data yang dikemukakan kepada lambda"}

Fungsi Lambda (contohnya ditulis dalam Python):

 # lambda_function.py
Import JSON

def lambda_handler (acara, konteks):
    data_to_process = json.loads (event ['body']) # menganggap bahawa permintaan pos diterima dari cetakan API Gateway (f "lambda adalah data pemprosesan: {data_to_process}")
    # Jalankan logik pemprosesan data intensif atau memori CPU di sini# ...
    kembali {
        'StatusCode': 200,
        'badan': json.dumps ({'mesej': 'pemprosesan data selesai'})
    }

Penyelesaian ini sepenuhnya menyerahkan pengurusan sumber pengkomputeran ke platform awan, memudahkan operasi dan penyelenggaraan.

Rancang pemilihan dan langkah berjaga -jaga

• Saderi : Ia paling sesuai untuk pemprosesan tugas tak segerak dalam ekosistem Python. Ia agak mudah untuk digunakan, tetapi ia memerlukan pengurusan broker dan pekerja.
• Apache Kafka / Rabbitmq : Sesuai untuk membina seni bina microservice yang lebih kompleks, sistem yang didorong oleh peristiwa, atau senario yang memerlukan daya tarikan dan ketekunan yang tinggi. Lebih banyak operasi dan pengetahuan penyelenggaraan profesional diperlukan.
• Fungsi Serverless Service Cloud : Ia paling sesuai untuk aplikasi awan asli, yang boleh mengurangkan beban operasi dan penyelenggaraan dan membayar atas permintaan, tetapi mungkin terdapat kelewatan permulaan sejuk dan masalah mengunci pembekal.

Nota:

• Dasar Perkongsian Data : Jika tugas yang tidak dipasang masih perlu mengakses data 8GB "cache", maka data itu sendiri perlu diluar. Pertimbangkan menyimpannya dalam sistem fail yang diedarkan, penyimpanan objek (seperti S3), cache yang diedarkan (seperti Redis, tetapi memerlukan penilaian semula tahap pengubahsuaian ke perpustakaan pihak ketiga), atau pangkalan data, dan bukannya memori pelayan web. Pemproses tugas kemudian dimuatkan atas permintaan dari storan bersama ini apabila dilaksanakan.
• Pemberitahuan Keputusan : Jika pelanggan perlu mengetahui hasil pemprosesan tugas, mekanisme perlu direka untuk memberitahu pelanggan, sebagai contoh:
  • Hasil tolak dalam masa nyata melalui WebSocket.
  • Pemilihan masa klien antara muka pertanyaan status tugas yang disediakan oleh FastAPI.
  • Selepas tugas selesai, FastAPI diberitahu melalui API panggil balik.
• Pengendalian dan pemantauan ralat : Semua tugas tak segerak memerlukan mekanisme pengendalian ralat yang teguh dan pemantauan lengkap untuk segera menemui dan menyelesaikan masalah.
• Konsistensi data : Dalam persekitaran pemprosesan decoupling dan asynchronous, isu konsistensi data perlu dipertimbangkan dengan teliti, terutamanya apabila menulis operasi terlibat.

Meringkaskan

Menghadapi konflik antara cache memori yang besar dan sambungan multi-proses dalam aplikasi FastAPI, secara langsung meningkatkan proses pekerja Gunicorn akan membawa kepada penggunaan ingatan yang tidak dapat diterima. Penyelesaian terbaik adalah mengamalkan seni bina yang didorong oleh peristiwa yang menghancurkan dan tugas-tugas intensif data dari pelayan web dan memprosesnya secara tidak segerak. Sama ada melalui giliran tugas saderi, kafka/rabbitmq queue mesej, atau fungsi perkhidmatan tanpa perkhidmatan awan, idea terasnya adalah untuk memastikan pelayan web ringan, memberi tumpuan kepada menjawab permintaan dengan cepat, dan menyerahkan kerja berat kepada perkhidmatan backend bebas dan berskala. Ini bukan sahaja mengoptimumkan penggunaan memori secara berkesan, tetapi juga meningkatkan keupayaan pemprosesan keserasian keseluruhan dan skalabilitas aplikasi. Memilih penyelesaian yang paling sesuai untuk persekitaran teknologi dan penyebaran teknologi anda, dan memberi perhatian kepada pautan utama seperti perkongsian data, pemberitahuan hasil, pengendalian ralat dan pemantauan akan membantu anda membina aplikasi FastAPI yang cekap dan mantap.

Atas ialah kandungan terperinci Pelanjutan Multi-Proses untuk mengoptimumkan Cache Memori Tinggi Fastapi: Amalan Senibina yang Didorong oleh Peristiwa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!