Wdrażanie za pomocą Gunicorn i Uvicorn
Poznają Państwo sposób wdrażania FastAPI na produkcji z użyciem Gunicorn jako menedżera procesów i workerów Uvicorn.
Wdrażanie za pomocą Gunicorn i Uvicorn to bezpłatna lekcja FastAPI Backend Development Bootcamp na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej FastAPI Backend Development Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
From Dev to Production
When you're developing a FastAPI app, you often run it using a simple command like uvicorn main:app --reload.
This is great for development, as it automatically restarts your server when you make changes. But it's not suitable for production environments.
Why? A single process isn't robust or scalable. If it crashes, your entire API goes down! Production needs stability, performance, and fault tolerance.
Uvicorn: The ASGI Heart
FastAPI is an ASGI framework. ASGI stands for Asynchronous Server Gateway Interface, a standard for Python web servers to communicate with asynchronous web applications.
Uvicorn is a lightning-fast ASGI server implementation. It's what allows your FastAPI application to handle requests asynchronously and efficiently.
Think of Uvicorn as the engine that powers your FastAPI car. It's fast, but it only has one driver (process) by itself.
Direct Uvicorn Run
Here's a basic FastAPI application. To run it directly with Uvicorn (as you might in development), you'd use a command in your terminal.
The uvicorn main:app --host 0.0.0.0 --port 8000 command tells Uvicorn to run the app object from the main.py file, making it accessible on all network interfaces at port 8000.
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello from FastAPI!"}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)Uvicorn's Production Gaps
While Uvicorn is excellent, running it directly (especially with --reload) isn't ideal for production because:
- Single Process: It typically runs as a single process, meaning it can only use one CPU core.
- No Worker Management: If that single process crashes, your API stops completely.
- No Process Supervision: Uvicorn doesn't automatically restart crashed workers or manage multiple instances for load balancing.
For production, we need something to manage Uvicorn workers.
Gunicorn: The Robust Manager
Enter Gunicorn (Green Unicorn)! Gunicorn is a production-ready WSGI HTTP server that can also manage ASGI applications (like FastAPI) by using specific worker classes.
Its main job is to act as a process manager. It spawns and supervises multiple worker processes, distributing incoming requests among them.
Think of Gunicorn as the pit crew chief, making sure all your Uvicorn engines are running smoothly and replacing them if one fails.
The Power Duo: Gunicorn & Uvicorn
The recommended way to deploy FastAPI in production is to combine Gunicorn with Uvicorn workers.
Here's how it works:
- Gunicorn (Master Process): Listens for incoming requests and distributes them. It also supervises its workers.
- Uvicorn (Worker Processes): Gunicorn spawns multiple Uvicorn instances. Each Uvicorn worker runs your FastAPI application.
This setup provides better performance, fault tolerance, and efficient resource utilization.
Gunicorn & Uvicorn in Action
To run the same FastAPI app using Gunicorn with Uvicorn workers, you would use a command like this. This setup is much more robust for production.
Here, -w 4 means 4 worker processes, and -k uvicorn.workers.UvicornWorker specifies that Gunicorn should use Uvicorn workers.
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello from FastAPI!"}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)Optimizing Worker Count
Deciding how many Gunicorn workers to use is crucial for performance. A common rule of thumb for CPU-bound applications is (2 * CPU_CORES) + 1.
For example, on a server with 4 CPU cores, you might start with (2 * 4) + 1 = 9 workers. This allows for some workers to handle I/O while others process CPU-intensive tasks.
Always monitor your server's resource usage (CPU, RAM) to fine-tune this number for your specific application load.
Securing Your Configuration
In production, never hardcode sensitive information like database credentials or API keys directly in your code.
Use environment variables instead. This keeps your secrets out of your codebase and makes your application more portable and secure.
FastAPI and Pydantic (which FastAPI uses) have excellent support for loading settings from environment variables, often through Pydantic's BaseSettings.
Deployment Check
Let's test your understanding of Gunicorn and Uvicorn roles in a production FastAPI deployment.
Recap: Robust Deployment
You've learned how to deploy FastAPI applications for production using the powerful combination of Gunicorn and Uvicorn.
- Uvicorn is the ASGI server that runs your FastAPI app.
- Gunicorn is the process manager that supervises multiple Uvicorn workers.
- This setup provides scalability, fault tolerance, and better resource utilization.
Remember to optimize your worker count and always use environment variables for sensitive configurations. Next, you might explore cloud deployment strategies!
Ucz się FastAPI Backend Development Bootcamp dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 21
- Lekcje
- 84
Często zadawane pytania
Czy lekcja „Wdrażanie za pomocą Gunicorn i Uvicorn” jest bezpłatna?
Tak — pełny tekst „Wdrażanie za pomocą Gunicorn i Uvicorn” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu FastAPI Backend Development Bootcamp, przejdź na CoddyKit PRO. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.
Co nauczysz się w „Wdrażanie za pomocą Gunicorn i Uvicorn”?
Poznają Państwo sposób wdrażania FastAPI na produkcji z użyciem Gunicorn jako menedżera procesów i workerów Uvicorn. Ćwiczysz FastAPI Backend Development Bootcamp z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć FastAPI Backend Development Bootcamp?
Nie wymagamy żadnego doświadczenia. FastAPI Backend Development Bootcamp w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.
Ile czasu zajmuje lekcja „Wdrażanie za pomocą Gunicorn i Uvicorn”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji FastAPI Backend Development Bootcamp?
Tak. Każda lekcja FastAPI Backend Development Bootcamp zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Konteneryzacja aplikacji FastAPI
- Wdrażanie za pomocą Gunicorn i Uvicorn
- Strategie wdrażania w chmurze
- Zarządzanie zmiennymi środowiskowymi i sekretami