For a production Django deployment, put Nginx at the public edge, let it serve collected static files, and have it pass dynamic requests over the uwsgi protocol to a separately managed uWSGI process. uWSGI loads the callable in project_name/wsgi.py, while Django selects its settings through DJANGO_SETTINGS_MODULE. This arrangement keeps TLS, connection handling and static-file delivery out of Django while giving you a supervised application process.
Need a server to try this on? Antihost offers Linux VPS plans with NVMe storage, full root access and a 14-day free trial.
The sequence is: prepare production settings, collect static assets, install and configure uWSGI, create a service for it, configure Nginx to use the same Unix socket (or a loopback TCP endpoint), test both configurations, then enable HTTPS and monitoring. Django’s runserver is not part of this production path; the Django documentation states that it is “a lightweight development server, which is not suitable for production.”
As an Amazon Associate I earn from qualifying purchases.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11How the Django, uWSGI and Nginx request path works
A browser connects to Nginx on the server’s public HTTP or HTTPS port. Nginx decides whether the URL identifies a static asset or an application route. A static request is read directly from the directory created by Django’s collectstatic command. A dynamic request is sent to uWSGI through a local endpoint using the uwsgi protocol. uWSGI imports Django’s WSGI callable and returns the response to Nginx, which sends it to the client.
The WSGI callable
A Django project created with startproject contains a wsgi.py module with an object named application. The uWSGI entry point is therefore normally:
#1 Best Overall
- BLUE LIGHT BLOCKING GLASSES: Our blue light glasses for women boast UV400 protection, blocking harmful blue rays from computer screens. With these bluelight glasses women, you can enjoy gaming, reading, or watching TV with no worries of eye strain.
- EYE RELIEF: Our blue light glasses are engineered to reduce blurry vision or strain caused by prolonged screen time. These womens blue light glasses aid in better sleep by preventing blue light from disrupting your natural sleep cycle, helping you fall asleep faster and enjoy a more restful night's sleep, making them the perfect christmas present.
- COMFORTABLE: Crafted from durable material, our trendy blue light glasses for woman or blue light glasses men ensure long-lasting comfort. The high-transmittance lenses accessories, gamer gifts for men, help keep your eyes relaxed. Perfect stocking stuffers, gifts for gamers men, christmas gifts for men, halloween costumes.
- LIGHTWEIGHT: These clear blue light glasses feature a lightweight frame, meaning they’ll stay comfy for long-term wear. Perfect as blue blockers glasses for women or mens blue light glasses, these non-prescription fake glasses for men can be worn throughout the day. The blue light blocking glasses women feature polycarbonate HD lenses, which are anti-reflective and restore true color.
- WORRY-FREE PURCHASE: If you experience any issues, our support team is ready to assist you quickly. These are the perfect costume glasses for cosplay dressing up.
project_name.wsgi:applicationThe text before the colon is the Python module; the text after it is the callable uWSGI invokes. The module must be importable from the directory supplied to uWSGI, and the process must use the same virtual environment that contains Django and your other dependencies.
The socket boundary
Nginx’s uwsgi_pass directive speaks the uwsgi protocol. It is not the same as an HTTP reverse-proxy connection, so a configuration using proxy_pass is not an interchangeable substitute. A Unix-domain socket keeps the hand-off on the host and can be protected with filesystem ownership and mode bits. A loopback TCP socket, such as 127.0.0.1:9000, is easier to inspect with network tools but must still be bound to loopback rather than a public interface.
Why static and dynamic traffic are split
Django’s application process should not spend workers reading immutable CSS, JavaScript, fonts or images. Nginx can deliver those files directly and apply long-lived caching headers. Requests that require URL routing, authentication, templates or database access continue to Django through uWSGI. Uploaded media is a separate concern: keep it outside the static tree, control its write permissions, and decide deliberately whether Nginx or an object-storage service should deliver it.
Prepare Django for a production release
Do this work before writing the Nginx file. A correctly functioning web server cannot compensate for unsafe Django settings or an application that only works with development defaults.
Set environment-specific settings
- Set
DEBUG = Falsein the production settings used by the service. - Provide a strong, private
SECRET_KEYthrough the service environment or another secret store; do not commit it to the repository. - Set
ALLOWED_HOSTSto the real hostnames and addresses that clients use. Do not use a wildcard unless you understand the consequences and have another host-validation boundary. - Configure the production database, email backend, cache and logging destinations explicitly.
- Define
STATIC_ROOTas a directory that Nginx can read. Keep it distinct from source-controlled application directories and from user-uploaded media. - Configure
MEDIA_ROOTandMEDIA_URLseparately when the application accepts uploads. - Set the HTTPS and secure-cookie options appropriate to your TLS topology. If TLS terminates at another trusted proxy, configure Django’s secure-proxy setting to match the header that proxy actually sends.
Forwarded headers are security-sensitive. Django must be able to reconstruct the original host, client address and scheme from the headers added by your real proxy chain, not from values that an Internet client can spoof directly.
Run Django’s deployment checks
Run the deployment validation command from the release environment:
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsRank #2
- WINDEX GAMING WIPES: effortlessly clean all your gaming gear and gaming electronics in one easy step with our new Windex Gaming Wipes
- AMMONIA FREE: our ammonia-free formula is safe to use on all of your favorite gaming equipment like consoles, headsets, controllers, screens, keyboards, and more
- PRE-MOISTENED WIPES: each wipe instantly removes dust, dirt, and stubborn smudges and fingerprints leaving a streak-free shine
- ANTI-STATIC: great for cleaning and wiping down your gaming gear and electronics leaving behind no visible residue
- COMPACT RESEALABLE PACKAGE: store your pack of Windex Gaming Wipes anywhere in your home for whenever a quick and easy wipedown is needed
python manage.py check --deployResolve the warnings it reports, then run your normal migrations and application tests. The deployment checklist covers HTTPS, critical settings, performance and error reporting; treat it as a release gate rather than an optional diagnostic.
Collect static files during the release
After installing the exact dependencies and selecting production settings, run:
python manage.py collectstaticThe command copies files from installed apps and configured static directories into STATIC_ROOT. Nginx must point to that resulting directory, not to an individual app’s development directory. Run the command again whenever static assets change as part of a new release.
Install and configure uWSGI
Install it in the application’s virtual environment
Activate the virtual environment used by the deployment and install uWSGI there, alongside Django and the project requirements:
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →python -m pip install uwsgiVerify that the executable resolves inside that environment:
which uwsgi
uwsgi --versionUse the absolute path to this executable in your service definition. A system service that accidentally calls a different global installation can load different Python packages or a different uWSGI build than the one you tested.
Rank #3
- Ergonomic & Adjustable Design: Fight "text neck" and improve your posture. Designed for comfort, it offers an adjustable height (7.1in-8.5in) (1.4in adjustable range) and angle (5°-85°) Please note: cell phone stand is only 9 inches tall—the length of a standard pencil
- Without blocking subtitles Perfect for office desk Tiktok Face Time Zoom video—this is the ultimate kitchen desk essential for phones! Perfect viewing experience while reducing neck back strain, A must-have for gamers streamers desk, and anyone who values both style and support!
- Sleek & Stable Design fits Otterbox Case: Say goodbye to bent cables, tangles, and tip-overs! LISEN’s stylish adjustable desk phone holder features a built-in charging hole and smart cable management, keeping your phone secure and your workspace clutter-free cool gadgets for men
- ANTI-SLIP DESIGN free hands: The under 10.00 items easy gadgets back and the bottom of this kitchen essentials for women are fully covered by anti-skid silicone, which LISEN stand up desk decor can provide maximum protection device from any scratches and slides
- Your Perfect Viewing Companion:If your product arrives damaged or breaks within 365 days, reach out to LISEN for a quick and hassle-free solution. Struggling with assembly, like tightening the screw? We’ve got your back! Your experience matters to us. (Product including: phone Holder stand*1, screw*1, hexagon screwdriver*1, specification*1)
Build a minimal uWSGI configuration
An ini file makes the process settings reviewable and keeps the service command short. The following is a template; replace paths, module names and the service account with values for your host:
[uwsgi]
chdir = /srv/example
module = project_name.wsgi:application
home = /srv/example/.venv
master = true
processes = 4
threads = 1
socket = /run/example/uwsgi.sock
chmod-socket = 660
vacuum = true
die-on-term = true
env = DJANGO_SETTINGS_MODULE=project_name.settings.production
harakiri = 60
max-requests = 5000
logto = /var/log/example/uwsgi.log
pidfile = /run/example/uwsgi.pidchdir is the project directory from which Python imports are resolved. home selects the virtual environment. module names the WSGI callable, and env tells Django which settings module to load. If your project uses a single settings module, use that module instead of the example production path.
Choose process controls deliberately
master = true gives uWSGI a supervising master process. processes controls the number of worker processes and must be sized for your memory, database connection limits and workload; there is no universal worker number. Threads are an application-specific choice, not a performance guarantee. Start with a conservative configuration, measure the target workload and increase capacity only while watching memory, response times, database saturation and error rates.
harakiri terminates a request that exceeds the specified timeout, protecting workers from a permanently stuck request. Set it above the longest legitimate operation, and investigate timeouts rather than simply making the value very large. max-requests recycles workers after a number of requests, which can limit the impact of leaks; choose a value based on observed behavior. The example numbers are operational settings, not benchmark-derived recommendations.
Test uWSGI before involving Nginx
Run uWSGI manually as the same user and from the same directory that the service will use. Confirm that it can import the project, open the socket and complete a request. Stop it with a normal termination signal after the test. This isolates Python import, settings and permission errors from Nginx configuration errors.
Run uWSGI under a service manager
Do not leave uWSGI attached to a shell or run it as the superuser. Create a dedicated unprivileged account, give it read access to the application and write access only to directories that require it, and arrange for the runtime socket and pid directories to be created with the correct ownership.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #4
- Easy Installation: Our gaming lights have been designed to enhance your entertainment experience. Simply position the led light bar next to your TV or game console to create a game room environment with ease. They come with USB power and a 60 inch cord for direct mounting and mobility
- Audio Syncing & Extensive Mode: The built-in high-sensitivity music sensor allows you to sync the TV led lights to your favorite music. Lights react and move to the beat of music, film and game audio, creating an incredible immersive sound and light experience – and all without the need for an additional hub. You can choose from 64+ patterns, including strobe, illusion, jump, energy, gradient, running, chasing, fluttering mode etc. Each mode can be applied to different scenes
- 64+ Chasing IC+RGB & W Effect: The independent control design of IC+RGB and white all-in-one multifunctional rgbw led bar lights monitor backlight allows you to easily switch the led lights for desk between IC+RGB and white to enjoy a variety of lighting effects, you can choose white lighting mode with high brightness for better illumination when working, etc. Choose IC+RGB lighting mode when you need to create an entertaining atmosphere for the light show, 16 million colours of Color changing rgb light bar let you dance to the beat and create a dynamic party atmosphere
- Dynamic and Dimmable Lights: 1%-full brightness free brightness adjustment gives you the flexibility to adjust dimmable led light bar for room decorations or a variety of occasions
- USB Powered: USB light bars for room can be powered by powernank, usb charger, TV, Monitor, laptop PC mainframe, making behind TV led lighting bar easy to install in any location.TV led lights are powered by the TV usb interface / PC mainframe, can be turned on/off synchronously with TV / PC
Example systemd unit
The paths below correspond to the sample ini file and must be adapted to your host:
[Unit]
Description=uWSGI service for the Django application
After=network.target
[Service]
User=example
Group=www-data
WorkingDirectory=/srv/example
Environment=DJANGO_SETTINGS_MODULE=project_name.settings.production
ExecStart=/srv/example/.venv/bin/uwsgi --ini /etc/example/uwsgi.ini
Restart=on-failure
[Install]
WantedBy=multi-user.targetEnsure that /run/example exists at startup and is writable by the uWSGI account, while the socket is readable by the Nginx group. On systems where the runtime directory is managed by systemd, add the appropriate runtime-directory options rather than creating a world-writable directory.
After installing the unit, reload systemd, enable the service and inspect its logs:
sudo systemctl daemon-reload
sudo systemctl enable --now example-uwsgi
sudo systemctl status example-uwsgi
sudo journalctl -u example-uwsgi -eKeep uWSGI logs and the service manager’s journal available during deployment. Import errors, permission failures and worker exits are much easier to diagnose before Nginx masks them as a generic gateway error.
Configure Nginx to pass requests to uWSGI
Define the upstream endpoint
For a Unix socket, define an upstream using the unix: form. A loopback TCP endpoint can be substituted if that is how uWSGI is configured:
upstream django_app {
server unix:/run/example/uwsgi.sock;
# Or: server 127.0.0.1:9000;
}The socket path must match the uWSGI setting exactly. A mismatch, a missing runtime directory or restrictive ownership produces an immediate connection failure.
Best Value
- Compatible with Wide Screens - To ensure compatibility with the dual monitor mount, your each monitor must meet three conditions at the same time: First, computer screens size range: 13 to 32 inches. Second, screen weight range: 4.4 to 19.8 lbs. Third, the back of the monitor screen must have VESA mounting holes with a pitch of 75x75mm or 100x100mm.
- Regarding the compatibility with desks - Your desk must meet three conditions at the same time: First, desk material: Only wooden desks are recommended, plastic or glass desks cannot be used. Second, desk thickness range: 0.59" - 3.54". Third, the bottom of the desk should not have any cross beams or panels, as this will interfere with installation. We recommend carefully checking that your desk and monitors meets all above conditions before purchasing.
- Dual C-Clamp Hold - Worried your dual monitors might wobble or slip? Our upgraded base uses a larger platform plus a dual C-clamp structure to lock the dual monitor arm firmly to your desk. Each arm safely keeps your screens steady while you type, click and game—no shaking, no sliding, just a clean and secure setup you can trust every day. It also provides Grommet Mounting installation choice, both options ensure stable and secure fixation for your 0.59" - 3.54" desk.
- Full-Motion Adjustment For Comfortable View - Pull the screen closer when you’re deep in a spreadsheet, push it back to watch videos, or rotate to portrait for coding — moving everything smoothly with just one hand. The monitor stand offers +85°/-50° tilt, ±90° swivel and 360° rotation. Raise your monitor up to 15.75″ to support a healthy sitting posture. Whether you’re working from home, gaming through the night, or switching between video calls and documents, getting the screens to your natural line of sight helps relieve neck, shoulder and back strain so you can stay focused longer with less fatigue.
- Keep Your Desk Organized: By lifting both screens off the desktop, this dual monitor stand opens up valuable space for your keyboard, notebook, docking station or a simple, clutter-free work area. Built-in cable management guides wires along the arms, keeping cords out of sight and out of the way. Enjoy a tidy, modern workstation that looks as good as it feels to use.
Serve static files and route application requests
A complete server block has separate locations for static assets and dynamic routes:
server {
listen 80;
server_name example.com www.example.com;
location /static/ {
alias /srv/example/staticfiles/;
}
location /media/ {
alias /srv/example/media/;
}
location / {
include /etc/nginx/uwsgi_params;
uwsgi_param Host $host;
uwsgi_param X-Real-IP $remote_addr;
uwsgi_param X-Forwarded-For $proxy_add_x_forwarded_for;
uwsgi_param X-Forwarded-Proto $scheme;
uwsgi_pass django_app;
}
}Many distributions install the parameter file at /etc/nginx/uwsgi_params; use the path supplied by your distribution if it differs. The minimal Nginx module pattern is an include uwsgi_params followed by uwsgi_pass. Explicit host, client-IP, forwarded-for and protocol parameters are useful when your proxy topology requires them. Do not blindly trust a forwarded value from an untrusted upstream; make sure Nginx overwrites or sanitizes headers at the Internet-facing boundary.
Free tools Windows power users keep installed
One-click scans. No signup required.
Understand alias and trailing slashes
With location /static/ and alias /srv/example/staticfiles/, a request for /static/admin/css/base.css maps to /srv/example/staticfiles/admin/css/base.css. Keep the trailing slash on both the location and alias in this pattern. A root directive uses a different path-concatenation rule, so switching between root and alias without recalculating the resulting filename is a common source of 404 responses.
Add HTTPS as a separate listener
In production, terminate TLS at Nginx or at a trusted load balancer in front of it. Redirect plain HTTP to HTTPS, install certificates through your normal certificate-management process, and configure secure cookies and CSRF origins in Django. If another proxy terminates TLS before Nginx, pass the original scheme only through a controlled header and configure Django to trust that exact header. A client must not be able to make Django believe an ordinary HTTP request was HTTPS simply by supplying an arbitrary header.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Serve static assets and protect uploaded media
Nginx documentation describes this division directly: static content is offloaded to Nginx or Nginx Plus, which serves it from a collected directory such as /var/django/projects/myapp/static. The practical consequence is that static files should be readable by the Nginx worker without granting it write access to your source tree.
Static-file checklist
- Set
STATIC_ROOTto the directory named by the Nginx static location. - Run
python manage.py collectstaticduring every release that changes assets. - Make the directory and its files readable by Nginx.
- Use cache headers for versioned or content-hashed files; shorten caching for filenames that can be replaced in place.
- Never route
/static/through Django in production unless you have a specific, documented reason.
Media-file checklist
- Keep
MEDIA_ROOTseparate fromSTATIC_ROOT. - Allow application code to write only where uploads are required; Nginx needs read access, not write access.
- Validate upload type, size and filename in Django, and prevent uploaded files from being executed as server-side code.
- Choose whether media is public. Private media generally needs authenticated application responses or a controlled download mechanism rather than an unrestricted Nginx alias.
- Back up media independently from deployable code and collected assets.
Validate, reload and observe the deployment
- Run
python manage.py check --deploywith the production settings. - Run migrations and
python manage.py collectstaticas the release user. - Check that the uWSGI service is active and that the socket exists:
sudo systemctl status example-uwsgiandls -l /run/example/uwsgi.sock. - Validate Nginx syntax before changing a running service:
sudo nginx -t. Fix every reported error. - Reload Nginx only after the test succeeds:
sudo systemctl reload nginx. - Request a static URL and a dynamic URL separately. A static 404 points to the collectstatic path or Nginx mapping; a dynamic failure points to the socket, uWSGI or Django.
- Inspect Nginx access and error logs together with the uWSGI and Django logs. Correlate timestamps, status codes and request IDs where your logging setup supports them.
Use a reload for configuration changes that do not require stopping workers. Restart uWSGI when deploying code or dependencies that the existing workers have already imported, and verify that the new process reaches a healthy state before declaring the release complete.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Secure and operate the stack
- Protect the socket: use a dedicated account, a restrictive group and mode such as
660; never place it in a directory writable by untrusted users. - Limit privileges: uWSGI should not run as root. Keep source, settings and secrets unreadable to unrelated accounts.
- Set bounded resources: configure worker counts, request timeouts, maximum request sizes and recycling based on measured behavior and available memory.
- Keep dependencies reproducible: pin and review Python packages, record the virtual-environment path and deploy from a known release.
- Use HTTPS: redirect HTTP, configure secure cookies and review CSRF and allowed-origin settings.
- Log usefully: retain Nginx access/error logs, uWSGI process logs and Django application errors with rotation and restricted access.
- Monitor failure modes: alert on repeated worker exits, socket connection errors, rising 5xx responses, request timeouts, disk exhaustion and database saturation.
- Review configuration changes: an incorrect Nginx or uWSGI setting can create security problems as well as outages, so validate changes and keep a rollback copy.
Troubleshoot common failures
| Symptom | Likely cause | Checks and fix |
|---|---|---|
| Nginx returns 502 Bad Gateway | uWSGI is stopped, the socket path is wrong, or Nginx cannot access the socket. | Inspect systemctl status example-uwsgi, verify the socket path in both files, check socket ownership and read/write permission for the Nginx group, then review Nginx’s error log. |
| Every dynamic URL is a 404 from Django | The request reaches Django, but URL configuration or the host-specific settings are incorrect. | Check the uWSGI log for the loaded settings module and test the route directly through Django’s URL configuration. This is not a static-file mapping problem. |
| Static files return 404 while pages load | collectstatic was not run, STATIC_ROOT differs from the Nginx alias, or the alias path is malformed. |
List the expected file under STATIC_ROOT, run collectstatic, and verify the trailing-slash alias mapping. |
| Static files return 403 | Nginx lacks directory traversal or file-read permission. | Check permissions on every parent directory and the files themselves. Grant read/execute access without making the tree writable by Nginx. |
| Django reports an invalid host | The hostname in the request is absent from ALLOWED_HOSTS, or a proxy is forwarding an unexpected host. |
Inspect the incoming host and Nginx’s uwsgi_param Host value, then add only the legitimate production names. |
| Secure redirects loop or Django thinks requests are HTTP | The TLS-terminating proxy’s scheme header is not being forwarded or trusted consistently. | Trace the proxy chain, set X-Forwarded-Proto at the trusted boundary, and configure Django’s secure-proxy setting to match it. |
| Workers disappear during long requests | The harakiri timeout is shorter than a legitimate operation, or the request is genuinely stuck. |
Compare request duration with the timeout, inspect application and database logs, and fix slow work or adjust the bounded timeout based on evidence. |
| uWSGI starts manually but fails under systemd | The unit uses a different working directory, virtual environment, environment variable or filesystem permissions. | Compare the manual command with ExecStart, use absolute paths, inspect journalctl -u example-uwsgi and verify the service account’s access. |
When this stack is the right interface
Django documents WSGI as its main synchronous interface and ASGI as the interface for asynchronous-friendly deployments. uWSGI plus Nginx is a sensible fit when your application is predominantly synchronous and you want a mature process model with Nginx handling TLS and static files. It is not automatically the best choice for long-lived asynchronous connections or code that depends on an ASGI server’s concurrency model.
| Decision area | uWSGI and Nginx deployment | What to evaluate in an alternative |
|---|---|---|
| Application interface | WSGI; synchronous Django callable such as project_name.wsgi:application. |
ASGI support if the application uses asynchronous views, websockets or other long-lived connections. |
| Worker lifecycle | uWSGI master and worker processes, request timeouts and optional recycling. | How the alternative starts, supervises, scales and replaces workers. |
| Static and media | Nginx serves collected static assets directly; media needs a separate policy. | Whether the platform includes an equivalent static layer and how uploads are stored. |
| TLS termination | Nginx can terminate HTTPS and forward the original scheme through controlled headers. | Which component owns certificates and how trusted proxy headers reach Django. |
| Observability | Nginx, uWSGI and Django each produce logs that must be correlated. | Whether metrics, traces, structured logs and health checks are built in. |
| Operational complexity | You manage Nginx paths, socket permissions, service units and deployment order. | Less host configuration may mean less control or different limits; compare the full lifecycle. |
Capacity planning without invented benchmarks
There is no authoritative generic throughput, latency or worker-count figure for a Django/uWSGI/Nginx installation. Capacity depends on view cost, database queries, external services, response size, memory and the hardware and network around it. Measure representative traffic on your own deployment.
Record response-time percentiles, 4xx and 5xx rates, worker busy time, memory per worker, database connection use, socket errors and disk space. Change one setting at a time, retest after code or dependency changes, and keep enough headroom for deploys and traffic spikes. A larger worker count can increase database contention or exhaust memory; a longer timeout can hide a stuck dependency. Treat both as hypotheses to validate, not as universal tuning rules.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
