uvicorn gunicorn fastapi docker
0.8.0
Gambar Docker ini sekarang sudah usang. Tidak perlu menggunakannya, Anda bisa menggunakan Uvicorn dengan --workers .
Baca lebih lanjut tentang itu di bawah ini.
Dockerfile masing -masingpython3.11 , latest (Dockerfile)python3.10 , (Dockerfile)python3.9 , (Dockerfile)python3.11-slim (Dockerfile)python3.10-slim (Dockerfile)python3.9-slim (Dockerfile) Tag ini tidak lagi didukung atau dipelihara, mereka dihapus dari repositori GitHub, tetapi versi terakhir yang didorong mungkin masih tersedia di Docker Hub jika ada yang menariknya:
python3.8python3.8-slimpython3.7python3.9-alpine3.14python3.8-alpine3.10python3.7-alpine3.8python3.6python3.6-alpine3.8Tag tanggal terakhir untuk versi ini adalah:
python3.8-2024-11-02python3.8-slim-2024-11-02python3.7-2024-11-02python3.9-alpine3.14-2024-03-11python3.8-alpine3.10-2024-01-29python3.7-alpine3.8-2024-03-11python3.6-2022-11-25python3.6-alpine3.8-2022-11-25 Catatan : Ada tag untuk setiap tanggal pembuatan. Jika Anda perlu "menyematkan" versi gambar Docker yang Anda gunakan, Anda dapat memilih salah satu tag tersebut. Misalnya tiangolo/uvicorn-gunicorn-fastapi:python3.11-2024-11-02 .
Gambar Docker dengan Uvicorn dikelola oleh Gunicorn untuk aplikasi web FASTAPI berkinerja tinggi di Python dengan kinerja auto-tuning.
Github Repo : https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker
Gambar Hub Docker : https://hub.docker.com/r/tiangolo/uvicorn-gunicorn-fastapi/
Fastapi telah terbukti sebagai kerangka kerja Python dengan salah satu kinerja terbaik, yang diukur dengan tolok ukur pihak ketiga, berkat didasarkan pada dan didukung oleh Starlette .
Kinerja yang dapat dicapai setara dengan (dan dalam banyak kasus lebih unggul dari) GO dan Node.js Frameworks.
Gambar ini memiliki mekanisme penyetelan otomatis yang termasuk untuk memulai sejumlah proses pekerja berdasarkan inti CPU yang tersedia. Dengan begitu Anda bisa menambahkan kode Anda dan mendapatkan kinerja tinggi secara otomatis, yang berguna dalam penyebaran sederhana .
Anda mungkin menggunakan kubernet atau alat serupa. Dalam hal ini, Anda mungkin tidak memerlukan gambar ini (atau gambar dasar serupa lainnya). Anda mungkin lebih baik membangun gambar Docker dari awal seperti yang dijelaskan dalam Docs for Fastapi dalam wadah - Docker: Bangun gambar Docker untuk Fastapi.
Jika Anda memiliki sekelompok mesin dengan Kubernetes , Docker Swarm Mode, NOMAD, atau sistem kompleks serupa lainnya untuk mengelola wadah terdistribusi pada beberapa mesin, maka Anda mungkin ingin menangani replikasi pada level cluster alih -alih menggunakan manajer proses (seperti Gunicorn dengan pekerja Uvicorn) di setiap kontainer, yang merupakan gambar Docker ini.
Dalam kasus -kasus tersebut (misalnya menggunakan Kubernetes) Anda mungkin ingin membangun gambar Docker dari awal , memasang dependensi Anda, dan menjalankan proses uvicorn tunggal alih -alih gambar ini.
Misalnya, Dockerfile Anda bisa terlihat seperti:
FROM python:3.9
WORKDIR /code
COPY ./requirements.txt /code/requirements.txt
RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
COPY ./app /code/app
CMD [ "uvicorn" , "app.main:app" , "--host" , "0.0.0.0" , "--port" , "80" ]Anda dapat membaca lebih lanjut tentang ini di dokumentasi FastAPI tentang: Fastapi di Containers - Docker.
Jika Anda pasti ingin memiliki banyak pekerja pada satu wadah, Uvicorn sekarang mendukung penanganan subproses, termasuk memulai kembali yang mati. Jadi tidak perlu Gunicorn untuk mengelola banyak pekerja dalam satu wadah.
Anda dapat memodifikasi contoh Dockerfile dari atas, menambahkan opsi --workers ke Uvicorn, seperti:
FROM python:3.9
WORKDIR /code
COPY ./requirements.txt /code/requirements.txt
RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
COPY ./app /code/app
CMD [ "uvicorn" , "app.main:app" , "--host" , "0.0.0.0" , "--port" , "80" , "--workers" , "4" ]Hanya itu yang Anda butuhkan. Anda tidak membutuhkan gambar Docker ini sama sekali. ?
Anda dapat membaca lebih lanjut tentang hal itu di dokumen Fastapi tentang penyebaran dengan Docker.
Uvicorn tidak memiliki dukungan untuk mengelola pemrosesan pekerja termasuk memulai kembali pekerja mati. Tapi sekarang itu terjadi.
Sebelum itu, Gunicorn dapat digunakan sebagai manajer proses, menjalankan pekerja Uvicorn. Kompleksitas tambahan ini tidak lagi diperlukan.
Sisa dokumen ini disimpan karena alasan historis, tetapi Anda mungkin tidak membutuhkannya. ?
tiangolo/uvicorn-gunicorn-fastapiGambar ini akan menetapkan konfigurasi yang masuk akal berdasarkan server yang sedang berjalan (jumlah core CPU yang tersedia) tanpa berkorban.
Ini memiliki default yang masuk akal, tetapi Anda dapat mengonfigurasinya dengan variabel lingkungan atau mengganti file konfigurasi.
Ada juga versi ramping. Jika Anda menginginkan salah satunya, gunakan salah satu tag dari atas.
tiangolo/uvicorn-gunicorn Gambar ini ( tiangolo/uvicorn-gunicorn-fastapi ) didasarkan pada tiangolo/uvicorn-gunicorn .
Gambar itu adalah apa yang sebenarnya dilakukan semua pekerjaan.
Gambar ini baru saja menginstal FASTAPI dan memiliki dokumentasi yang secara khusus ditargetkan di FastAPI.
Jika Anda merasa percaya diri tentang pengetahuan Anda tentang Uvicorn, Gunicorn dan Asgi, Anda dapat menggunakan gambar itu secara langsung.
tiangolo/uvicorn-gunicorn-starletteAda gambar Docker Sibling: Tiangolo/Uvicorn-Gunicorn-Starlette
Jika Anda membuat aplikasi web Starlette baru dan Anda ingin membuang semua fitur tambahan dari Fastapi, Anda harus menggunakan Tiangolo/Uvicorn-Gunicorn-Starlette sebagai gantinya.
Catatan : Fastapi didasarkan pada Starlette dan menambahkan beberapa fitur di atasnya. Berguna untuk API dan kasus lain: validasi data, konversi data, dokumentasi dengan OpenAPI, injeksi ketergantungan, keamanan/otentikasi dan lainnya.
Anda tidak perlu mengkloning repo GitHub.
Anda dapat menggunakan gambar ini sebagai gambar dasar untuk gambar lain.
Dengan asumsi Anda memiliki file requirements.txt , Anda dapat memiliki Dockerfile seperti ini:
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.11
COPY ./requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
COPY ./app /app Ini akan mengharapkan file di /app/app/main.py .
Atau file di /app/main.py .
Dan akan mengharapkannya berisi app variabel dengan aplikasi FASTAPI Anda.
Kemudian Anda dapat membangun gambar Anda dari direktori yang memiliki Dockerfile Anda, misalnya:
docker build -t myimage ./Dockerfile dengan: FROM tiangolo/uvicorn-gunicorn-fastapi:python3.11
COPY ./requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
COPY ./app /appapp dan masukkan di dalamnya.main.py dengan: from fastapi import FastAPI
app = FastAPI ()
@ app . get ( "/" )
def read_root ():
return { "Hello" : "World" }
@ app . get ( "/items/{item_id}" )
def read_item ( item_id : int , q : str = None ):
return { "item_id" : item_id , "q" : q } .
├── app
│ └── main.py
└── Dockerfile
Dockerfile Anda, berisi direktori app Anda).docker build -t myimage .docker run -d --name mycontainer -p 80:80 myimageSekarang Anda memiliki server FASTAPI yang dioptimalkan dalam wadah Docker. Auto-tuned untuk server Anda saat ini (dan jumlah core CPU).
Anda harus dapat memeriksanya di URL wadah Docker Anda, misalnya: http://192.168.99.100/items/5?q=someQuery atau http://127.0.1/items/5?q=someQuery (atau setara, menggunakan host Docker Anda).
Anda akan melihat sesuatu seperti:
{ "item_id" : 5 , "q" : " somequery " }Sekarang Anda dapat pergi ke http://192.168.99.100/docs atau http://127.0.0.1/docs (atau setara, menggunakan host Docker Anda).
Anda akan melihat dokumentasi API interaktif otomatis (disediakan oleh Swagger UI):
Dan Anda juga dapat pergi ke http://192.168.99.100/redoc atau http://127.0.0.1/redoc(or setara, menggunakan host Docker Anda).
Anda akan melihat dokumentasi otomatis alternatif (disediakan oleh redoc):
Anda mungkin juga ingin menambahkan dependensi untuk aplikasi Anda dan menyematkannya ke versi tertentu, mungkin termasuk Uvicorn, Gunicorn, dan Fastapi.
Dengan cara ini Anda dapat memastikan aplikasi Anda selalu berfungsi seperti yang diharapkan.
Anda dapat menginstal paket dengan perintah pip di Dockerfile Anda, menggunakan requirements.txt , atau bahkan menggunakan puisi.
Dan kemudian Anda dapat meningkatkan ketergantungan itu dengan cara yang dikendalikan, menjalankan tes Anda, memastikan bahwa semuanya berfungsi, tetapi tanpa melanggar aplikasi produksi Anda jika beberapa versi baru tidak kompatibel.
Berikut adalah contoh kecil dari salah satu cara Anda dapat menginstal ketergantungan Anda memastikan Anda memiliki versi yang disematkan untuk setiap paket.
Katakanlah Anda memiliki proyek yang dikelola dengan puisi, jadi, Anda memiliki dependensi paket dalam file pyproject.toml . Dan mungkin poetry.lock file.lock.
Maka Anda bisa memiliki Dockerfile menggunakan Docker Multi-Stage Building dengan:
FROM python:3.9 as requirements-stage
WORKDIR /tmp
RUN pip install poetry
COPY ./pyproject.toml ./poetry.lock* /tmp/
RUN poetry export -f requirements.txt --output requirements.txt --without-hashes
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.11
COPY --from=requirements-stage /tmp/requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
COPY ./app /appItu akan:
./poetry.lock* (diakhiri dengan * ), itu tidak akan macet jika file itu belum tersedia.Penting untuk menyalin kode aplikasi setelah menginstal dependensi, dengan cara itu Anda dapat memanfaatkan cache Docker. Dengan begitu tidak perlu menginstal semuanya dari awal setiap kali Anda memperbarui file aplikasi Anda, hanya ketika Anda menambahkan dependensi baru.
Ini juga berlaku untuk cara lain yang Anda gunakan untuk menginstal dependensi Anda. Jika Anda menggunakan requirements.txt , salin sendiri dan instal semua dependensi di bagian atas Dockerfile , dan tambahkan kode aplikasi Anda setelahnya.
Ini adalah variabel lingkungan yang dapat Anda atur dalam wadah untuk mengonfigurasinya dan nilai defaultnya:
MODULE_NAME"Modul" Python (file) yang akan diimpor oleh Gunicorn, modul ini akan berisi aplikasi yang sebenarnya dalam suatu variabel.
Secara default:
app.main jika ada file /app/app/main.py ataumain jika ada file /app/main.py Misalnya, jika file utama Anda adalah di /app/custom_app/custom_main.py , Anda bisa mengaturnya seperti:
docker run -d -p 80:80 -e MODULE_NAME= " custom_app.custom_main " myimageVARIABLE_NAMEVariabel di dalam modul Python yang berisi aplikasi FASTAPI.
Secara default:
appMisalnya, jika file Python utama Anda memiliki sesuatu seperti:
from fastapi import FastAPI
api = FastAPI ()
@ api . get ( "/" )
def read_root ():
return { "Hello" : "World" } Dalam hal ini api akan menjadi variabel dengan aplikasi FASTAPI. Anda bisa mengaturnya seperti:
docker run -d -p 80:80 -e VARIABLE_NAME= " api " myimageAPP_MODULEString dengan modul Python dan nama variabel diteruskan ke Gunicorn.
Secara default, setel berdasarkan variabel MODULE_NAME dan VARIABLE_NAME :
app.main:app ataumain:appAnda dapat mengaturnya seperti:
docker run -d -p 80:80 -e APP_MODULE= " custom_app.custom_main:api " myimageGUNICORN_CONFJalur ke file konfigurasi python gunicorn.
Secara default:
/app/gunicorn_conf.py jika ada/app/app/gunicorn_conf.py jika ada/gunicorn_conf.py (default yang disertakan)Anda dapat mengaturnya seperti:
docker run -d -p 80:80 -e GUNICORN_CONF= " /app/custom_gunicorn_conf.py " myimageAnda dapat menggunakan file konfigurasi dari gambar dasar sebagai titik awal untuk Anda.
WORKERS_PER_COREGambar ini akan memeriksa berapa banyak core CPU yang tersedia di server saat ini yang menjalankan wadah Anda.
Ini akan mengatur jumlah pekerja ke jumlah core CPU yang dikalikan dengan nilai ini.
Secara default:
1Anda dapat mengaturnya seperti:
docker run -d -p 80:80 -e WORKERS_PER_CORE= " 3 " myimage Jika Anda menggunakan nilai 3 di server dengan 2 core CPU, itu akan menjalankan 6 proses pekerja.
Anda dapat menggunakan nilai titik mengambang juga.
Jadi, misalnya, jika Anda memiliki server besar (katakanlah, dengan 8 core CPU) menjalankan beberapa aplikasi, dan Anda memiliki aplikasi FASTAPI yang Anda tahu tidak perlu kinerja tinggi. Dan Anda tidak ingin membuang sumber daya server. Anda bisa membuatnya menggunakan 0.5 pekerja per inti CPU. Misalnya:
docker run -d -p 80:80 -e WORKERS_PER_CORE= " 0.5 " myimageDi server dengan 8 core CPU, ini akan membuatnya hanya mulai 4 proses pekerja.
Catatan : Secara default, jika WORKERS_PER_CORE adalah 1 dan server hanya memiliki 1 inti CPU, alih -alih memulai 1 pekerja tunggal, itu akan dimulai 2. Ini untuk menghindari kinerja yang buruk dan memblokir aplikasi (aplikasi server) pada mesin kecil (mesin server/cloud/etc). Ini dapat ditimpa menggunakan WEB_CONCURRENCY .
MAX_WORKERSAtur jumlah maksimum pekerja untuk digunakan.
Anda dapat menggunakannya untuk membiarkan gambar menghitung jumlah pekerja secara otomatis tetapi memastikan itu terbatas pada maksimum.
Ini dapat berguna, misalnya, jika setiap pekerja menggunakan koneksi database dan database Anda memiliki batas maksimum koneksi terbuka.
Secara default itu tidak diatur, artinya tidak terbatas.
Anda dapat mengaturnya seperti:
docker run -d -p 80:80 -e MAX_WORKERS= " 24 " myimageIni akan membuat gambar dimulai paling banyak 24 pekerja, terlepas dari berapa banyak core CPU yang tersedia di server.
WEB_CONCURRENCYMengamati definisi otomatis jumlah pekerja.
Secara default:
WORKERS_PER_CORE . Jadi, di server dengan 2 core, secara default akan diatur ke 2 .Anda dapat mengaturnya seperti:
docker run -d -p 80:80 -e WEB_CONCURRENCY= " 2 " myimageIni akan membuat gambar memulai 2 proses pekerja, terlepas dari berapa banyak core CPU yang tersedia di server.
HOST"Tuan rumah" yang digunakan oleh Gunicorn, IP tempat Gunicorn akan mendengarkan permintaan.
Ini adalah tuan rumah di dalam wadah.
Jadi, misalnya, jika Anda mengatur variabel ini ke 127.0.0.1 , itu hanya akan tersedia di dalam wadah, bukan di host yang menjalankannya.
Ini disediakan untuk kelengkapan, tetapi Anda mungkin tidak boleh mengubahnya.
Secara default:
0.0.0.0PORTPort yang harus didengarkan wadah.
Jika Anda menjalankan wadah Anda di lingkungan terbatas yang memaksa Anda untuk menggunakan beberapa port tertentu (seperti 8080 ), Anda dapat mengaturnya dengan variabel ini.
Secara default:
80Anda dapat mengaturnya seperti:
docker run -d -p 80:8080 -e PORT= " 8080 " myimageBINDTuan rumah dan pelabuhan yang sebenarnya diteruskan ke Gunicorn.
Secara default, setel berdasarkan variabel HOST dan PORT .
Jadi, jika Anda tidak mengubah apa pun, itu akan ditetapkan secara default ke:
0.0.0.0:80Anda dapat mengaturnya seperti:
docker run -d -p 80:8080 -e BIND= " 0.0.0.0:8080 " myimageLOG_LEVELLevel log untuk Gunicorn.
Salah satu:
debuginfowarningerrorcritical Secara default, atur ke info .
Jika Anda perlu memeras lebih banyak penebangan berkorban kinerja, atur ke warning , misalnya:
Anda dapat mengaturnya seperti:
docker run -d -p 80:8080 -e LOG_LEVEL= " warning " myimageWORKER_CLASSKelas yang akan digunakan oleh Gunicorn untuk para pekerja.
Secara default, diatur ke uvicorn.workers.UvicornWorker .
Fakta bahwa ia menggunakan Uvicorn adalah apa yang memungkinkan penggunaan kerangka kerja ASGI seperti FastAPI, dan itulah yang memberikan kinerja maksimum.
Anda mungkin tidak boleh mengubahnya.
Tetapi jika karena alasan tertentu Anda perlu menggunakan pekerja uvicorn alternatif: uvicorn.workers.UvicornH11Worker Anda dapat mengaturnya dengan variabel lingkungan ini.
Anda dapat mengaturnya seperti:
docker run -d -p 80:8080 -e WORKER_CLASS= " uvicorn.workers.UvicornH11Worker " myimageTIMEOUTPekerja yang diam selama lebih dari ini banyak detik terbunuh dan dimulai kembali.
Baca lebih lanjut tentang itu di Dokumen Gunicorn: Timeout.
Secara default, diatur ke 120 .
Perhatikan bahwa kerangka kerja Uvicorn dan ASGI seperti Fastapi adalah async, bukan sinkronisasi. Jadi mungkin aman untuk memiliki batas waktu yang lebih tinggi daripada untuk menyinkronkan pekerja.
Anda dapat mengaturnya seperti:
docker run -d -p 80:8080 -e TIMEOUT= " 20 " myimageKEEP_ALIVEJumlah detik untuk menunggu permintaan pada koneksi tetap hidup.
Baca lebih lanjut tentang hal itu di Dokumen Gunicorn: Keepalive.
Secara default, diatur ke 2 .
Anda dapat mengaturnya seperti:
docker run -d -p 80:8080 -e KEEP_ALIVE= " 20 " myimageGRACEFUL_TIMEOUTBatas waktu untuk restart pekerja yang anggun.
Baca lebih lanjut tentang hal itu di Dokumen Gunicorn: waktu yang anggun.
Secara default, diatur ke 120 .
Anda dapat mengaturnya seperti:
docker run -d -p 80:8080 -e GRACEFUL_TIMEOUT= " 20 " myimageACCESS_LOGFile log akses untuk ditulis.
Secara default "-" , yang berarti stdout (cetak di log Docker).
Jika Anda ingin menonaktifkan ACCESS_LOG , atur ke nilai kosong.
Misalnya, Anda bisa menonaktifkannya dengan:
docker run -d -p 80:8080 -e ACCESS_LOG= myimageERROR_LOGFile log kesalahan yang harus ditulis.
Secara default "-" , yang berarti stderr (cetak di log docker).
Jika Anda ingin menonaktifkan ERROR_LOG , atur ke nilai kosong.
Misalnya, Anda bisa menonaktifkannya dengan:
docker run -d -p 80:8080 -e ERROR_LOG= myimageGUNICORN_CMD_ARGS Pengaturan baris perintah tambahan untuk Gunicorn dapat diteruskan di variabel lingkungan GUNICORN_CMD_ARGS .
Baca lebih lanjut tentang itu di Gunicorn Docs: Pengaturan.
Pengaturan ini akan diutamakan daripada variabel lingkungan lain dan file konfigurasi Gunicorn apa pun.
Misalnya, jika Anda memiliki sertifikat TLS/SSL khusus yang ingin Anda gunakan, Anda dapat menyalinnya ke gambar Docker atau memasangnya di dalam wadah, dan mengatur --keyfile dan --certfile ke lokasi file, misalnya:
docker run -d -p 80:8080 -e GUNICORN_CMD_ARGS= " --keyfile=/secrets/key.pem --certfile=/secrets/cert.pem " -e PORT=443 myimageCatatan : Alih -alih menangani sendiri TLS/SSL dan mengonfigurasinya di wadah, disarankan untuk menggunakan "proxy terminasi TLS" seperti Traefik. Anda dapat membaca lebih lanjut tentang hal itu dalam dokumentasi FASTAPI tentang HTTPS.
PRE_START_PATHJalan di mana menemukan skrip pra-awal.
Secara default, atur ke /app/prestart.sh .
Anda dapat mengaturnya seperti:
docker run -d -p 80:8080 -e PRE_START_PATH= " /custom/script.sh " myimage Gambar termasuk file konfigurasi python gunicorn default di /gunicorn_conf.py .
Ini menggunakan variabel lingkungan yang dinyatakan di atas untuk mengatur semua konfigurasi.
Anda dapat mengganti dengan memasukkan file di:
/app/gunicorn_conf.py/app/app/gunicorn_conf.py/gunicorn_conf.py/app/prestart.sh Jika Anda perlu menjalankan apa pun sebelum memulai aplikasi, Anda dapat menambahkan file prestart.sh ke direktori /app . Gambar akan secara otomatis mendeteksi dan menjalankannya sebelum memulai semuanya.
Misalnya, jika Anda ingin menambahkan migrasi Alembic SQL (dengan SQLalchemy), Anda dapat membuat file ./app/prestart.sh di direktori kode Anda (yang akan disalin oleh Dockerfile Anda) dengan:
#! /usr/bin/env bash
# Let the DB start
sleep 10 ;
# Run migrations
alembic upgrade head Dan itu akan menunggu 10 detik untuk memberikan database waktu untuk memulai dan kemudian menjalankan perintah alembic itu.
Jika Anda perlu menjalankan skrip python sebelum memulai aplikasi, Anda dapat membuat file /app/prestart.sh menjalankan skrip python Anda, dengan sesuatu seperti:
#! /usr/bin/env bash
# Run custom Python script before starting
python /app/my_custom_prestart_script.py Anda dapat menyesuaikan lokasi skrip prestart dengan variabel lingkungan PRE_START_PATH dijelaskan di atas.
Program default yang dijalankan adalah di /start.sh . Itu melakukan semua yang dijelaskan di atas.
Ada juga versi untuk pengembangan dengan Live Auto-reload di:
/start-reload.shUntuk pengembangan, bermanfaat untuk dapat memasang konten kode aplikasi di dalam wadah sebagai "volume host" Docker, untuk dapat mengubah kode dan mengujinya secara langsung, tanpa harus membangun gambar setiap saat.
Dalam hal ini, ini juga berguna untuk menjalankan server dengan pemuatan otomatis langsung, sehingga memulai kembali secara otomatis pada setiap perubahan kode.
Skrip tambahan /start-reload.sh menjalankan Uvicorn saja (tanpa Gunicorn) dan dalam satu proses.
Ini sangat ideal untuk pengembangan.
Misalnya, alih -alih menjalankan:
docker run -d -p 80:80 myimageAnda bisa berlari:
docker run -d -p 80:80 -v $( pwd ) :/app myimage /start-reload.sh-v $(pwd):/app : berarti direktori $(pwd) harus dipasang sebagai volume di dalam wadah AT /app .$(pwd) : Menjalankan pwd ("Print Working Directory") dan menempatkannya sebagai bagian dari string./start-reload.sh : Menambahkan sesuatu (seperti /start-reload.sh ) di akhir perintah, menggantikan "perintah" default dengan yang ini. Dalam hal ini, ini menggantikan default ( /start.sh ) dengan alternatif pengembangan /start-reload.sh . As /start-reload.sh tidak berjalan dengan Gunicorn, salah satu konfigurasi yang Anda masukkan ke dalam file gunicorn_conf.py tidak akan berlaku.
Tetapi variabel lingkungan ini akan bekerja sama seperti yang dijelaskan di atas:
MODULE_NAMEVARIABLE_NAMEAPP_MODULEHOSTPORTLOG_LEVEL Singkatnya: Anda mungkin tidak boleh menggunakan Alpine untuk proyek Python, alih -alih menggunakan versi gambar slim Docker.
Apakah Anda ingin detail lebih lanjut? Lanjutkan Membaca?
Alpine lebih berguna untuk bahasa lain di mana Anda membangun biner statis dalam satu tahap gambar Docker (menggunakan bangunan Docker multi-tahap) dan kemudian menyalinnya ke gambar Alpine sederhana, dan kemudian hanya menjalankan biner itu. Misalnya, menggunakan Go.
Tetapi untuk Python, karena Alpine tidak menggunakan perkakas standar yang digunakan untuk membangun ekstensi Python, saat memasang paket, dalam banyak kasus Python ( pip ) tidak akan menemukan paket yang dapat diinstal (roda ") untuk alpine. Dan setelah men -debug banyak kesalahan aneh, Anda akan menyadari bahwa Anda harus menginstal banyak alat tambahan dan membangun banyak ketergantungan hanya untuk menggunakan beberapa paket Python yang umum ini. ?
Ini berarti bahwa, meskipun gambar alpine asli mungkin kecil, Anda berakhir dengan gambar dengan ukuran yang sebanding dengan ukuran yang akan Anda dapatkan jika Anda baru saja menggunakan gambar Python standar (berdasarkan Debian), atau dalam beberapa kasus bahkan lebih besar. ?
Dan dalam semua kasus tersebut, akan membutuhkan waktu lebih lama untuk membangun, mengkonsumsi lebih banyak sumber daya, membangun ketergantungan lebih lama, dan juga meningkatkan jejak karbonnya, karena Anda menggunakan lebih banyak waktu dan energi CPU untuk setiap bangunan. ?
Jika Anda ingin gambar Python ramping, Anda harus mencoba dan menggunakan versi slim yang masih didasarkan pada Debian, tetapi lebih kecil. ?
Semua tag gambar, konfigurasi, variabel lingkungan dan opsi aplikasi diuji.
--workers . PR #303 oleh @Tiangolo.issue-manager.yml . PR #343 oleh @Tiangolo.latest-changes . PR #340 oleh @Tiangolo.latest-changes.yml . PR #276 oleh @alejsdev.README.md . PR #275 oleh @alejsdev.README.md . PR #274 oleh @alejsdev. Sorotan rilis ini:
python3.6-2022-11-25 .slim . PR #40.WORKER_CLASSTIMEOUTKEEP_ALIVEGRACEFUL_TIMEOUTACCESS_LOGERROR_LOGGUNICORN_CMD_ARGSMAX_WORKERSPRE_START_PATH custom env var. PR #33.tiangolo/uvicorn-gunicorn-fastapi:python3.7-2019-10-15 . PR #17./start-reload.sh , periksa dokumentasi yang diperbarui. PR #6 dalam gambar orang tua.WORKERS_PER_CORE secara default ke 1 , karena ditunjukkan untuk memiliki kinerja terbaik pada tolok ukur.WEB_CONCURRENCY tidak diatur, ke minimal 2 pekerja. Ini untuk menghindari kinerja yang buruk dan pemblokiran aplikasi (aplikasi server) pada mesin kecil (mesin server/cloud/etc). Ini dapat ditimpa menggunakan WEB_CONCURRENCY . Ini berlaku misalnya dalam kasus di mana WORKERS_PER_CORE diatur ke 1 (default) dan server hanya memiliki 1 inti CPU. PR #6 dan PR #5 dalam gambar induk./start.sh berjalan secara mandiri, membaca dan menghasilkan variabel lingkungan default yang digunakan. Dan hapus /entrypoint.sh karena tidak memodifikasi apa pun dalam sistem, hanya membaca variabel lingkungan. PR #4 dalam gambar orang tua./app/prestart.sh . Proyek ini dilisensikan berdasarkan ketentuan lisensi MIT.
