Recommended Free Tools
iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Antihost offers Linux VPS plans with full root access, unlimited traffic on a 1 Gbps port and a 14-day free trial.
The dependable small-VPS layout is FastAPI running under Uvicorn workers managed by Gunicorn, with Nginx handling the public connection and HTTPS. Keep the application in a Python virtual environment, keep the NoSQL database private, load credentials from protected environment configuration, and supervise the service so it starts on boot and restarts after failure.
This guide walks through that layout from an empty Linux VPS to a verified deployment. The database driver, URI format, indexes, pooling, backup method, and transaction behavior remain specific to the NoSQL engine you select.
The deployment shape
A production FastAPI deployment has several separate responsibilities. Keeping them separate makes failures easier to diagnose and lets you change one layer without rewriting the others.
| Layer | Responsibility | Recommended choice for a self-managed VPS |
|---|---|---|
| Application | Routes, validation, business logic, and database access | FastAPI application object in an importable Python module |
| ASGI server | Accepts ASGI requests and runs the application | Uvicorn |
| Process manager | Starts processes, handles restarts, and coordinates workers | Gunicorn with a Uvicorn worker, supervised by systemd |
| Reverse proxy | Public listener, request routing, logs, limits, and TLS boundary | Nginx |
| NoSQL service | Persistent application data | The engine and managed or self-hosted deployment you have chosen |
For local development, Uvicorn’s reload mode is useful. It is not a production setting: the FastAPI documentation warns that --reload uses more resources and is less stable. Production should run without reload, behind supervision and normally behind Nginx.
#1 Best Overall
- Powerful Turbo Fan:CAGIWIRU Electric Air Duster have reached speed up to 130000RPM,Can efficient remove dust and debris.With LED light and Three Adjustable Speed to meet with different cleaning tasks.
- With Attached USB C Fasting Charging cable.Charing 3 hours,Enjoy up to 240 minutes of use on the lowest setting, For third speed can use for 25mins.with four charging options to meet with your needs.
- Wide Application: attached 5 different nozzles,making it suitable for a variety of scenes, such as car,pet, pc, keyboards, and other electronic devices. It also serves for office and home clean duster.
- Handy Design & Portable:Cordless air duster electric nozzle is Light weight and small size, design and comfortable to hold and space saving, convenient to carry around. You can put it in your room or inside the car without taking up space.
- Economical &Reusable: Built durable materials with a long-lasting battery,our CAGIWIRU air duster it's a sustainable alternative to disposable air cans.
Decide what the VPS will host
Before installing software, decide whether the database runs on this machine or on a separate private or managed service. Running both application and database on one VPS is simple and can be inexpensive, but they compete for memory, disk, and CPU and can fail together. A separate service reduces maintenance on the VPS but introduces network dependency and a second security boundary.
- Use a dedicated deployment user instead of running the API as root.
- Plan a private path to the database. If the database is on the VPS, bind it to a private interface or local socket rather than exposing its native port publicly.
- Record the database engine, driver, URI format, database name, credentials, index plan, backup method, and retention policy.
- Choose where TLS terminates. Nginx on the VPS is the usual choice for a small self-hosted installation; an external proxy or load balancer is another valid topology.
- Estimate memory for Nginx, the API workers, Python overhead, and database or driver connection pools. Add workers only after observing actual memory use.
1. Prepare the Linux VPS
Create a deployment account
Log in with your provider’s administrative account long enough to create a non-root user, then perform routine deployment work as that user. Give the account only the privileges it needs for updates, the application directory, and service administration.
sudo adduser fastapi-app
sudo mkdir -p /srv/fastapi-app
sudo chown -R fastapi-app:fastapi-app /srv/fastapi-appThe username and path are examples; keep them consistent in the service and proxy configuration. Do not place secrets in the source tree or commit them to version control.
Patch the operating system and restrict the firewall
Apply the Linux distribution’s security updates before deploying. Configure its firewall so only the administration port you actually use and the public web ports required by Nginx are reachable. Do not open the Uvicorn port or the NoSQL port to the internet. If the database is remote, permit database traffic only from the VPS address or private network that needs it.
Choose the application directory
Keep the checkout, virtual environment, logs, and service-owned runtime files in predictable locations. A layout such as /srv/fastapi-app for code and /run/fastapi-app for a runtime socket makes ownership and cleanup straightforward.
2. Create the FastAPI project
Make an isolated Python environment
Install a supported Python version from your distribution or approved runtime source, then create a virtual environment owned by the deployment user. The FastAPI repository demonstrates installing the standard server dependencies with:
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Rank #2
- Screen Cleaner is Your Screen’s New Bestfriend! - EVEO is proud to present a screen cleaner that’s perfectly suited for your TV. Meet your new screen cleaner, computer screen cleaner, laptop cleaner, iPad cleaner, Macbook,tv cleaner or any other electronic device. Our screen cleaner spray and wipe along with the included plush microfiber cloth, easily removes dust, fingerprints & other smudges on the screen’s surface. Clean effectively for a streak-free screen
- Gentle on your Screens - Our screen cleaner spray and wipes is compatible to be used even for the most sensitive LCD, LED, CRT, and OLED screens in proper use. Be at ease knowing that this product is compatible with all the major brands: LG, SONY, Samsung, Sharp, iPad, iPhone, Android screens, Kindle, PC monitors - we’ve got you covered! Can be used as LCD screen cleaner, tv cleaner, smart tv screen cleaner, and more
- Premium Super Soft Plush Microfiber Cloth - Included in this efficient screen cleaning kit. This screen cleaner spray and wipe has our signature plush microfiber cloth specially designed to comply with screens and monitors and leave them streak-free. Has been shown to effectively absorbs stubborn stains, zero streaks, and no fiber shedding. Always use this together with our screen cleaner for the best results
- Easy-to-Use Screen Cleaner Kit + microfiber cleaning cloth - The EVEO Screen Cleaning Kit will easily be your new favorite tool when it comes to taking care of the things you love most, quick and easy solution for a streak-free screen. Simply screw on the sprayer gun on the screen cleaner bottle. Spray the cleaning liquid onto the microfiber cloth, then wipe the screen until desired cleanliness & shine is achieved.
- Quality Screen Care Kit Worth Purchasing - Enjoy a convenient Screen Cleaner anytime, anywhere you need it. Your satisfaction is our top priority. We stand behind the quality of our products and that’s why, you shouldn’t be worrying at all. We manufacture the Best Screen Cleaner. and can be used for laptop cleaning kit, laptop screen cleaner, tv screen cleaner for smart tv. MacBook screen cleaner, monitor cleaner or screen cleaner spray for electronic devices with microfiber cleaning cloth
cd /srv/fastapi-app
python3 -m venv .venv
. .venv/bin/activate
python -m pip install --upgrade pip
uv add "fastapi[standard]"If your workflow does not use uv, install the same packages with the package-management workflow your project already uses. Add Gunicorn and the driver for your selected NoSQL engine to the same environment. Keep a lock file or pinned dependency set so a later restart does not silently change the runtime.
Use an importable application object
A minimal project can be organized as:
app/
main.py
settings.py
db.py
routers/main.py must expose an object named app (or another name that you use in the server command):
from fastapi import FastAPI
app = FastAPI()
@app.get("/health")
async def health():
return {"status": "ok"}The import-string form is module:app. With the file above, the value is app.main:app when the project directory is on Python’s import path.
Keep configuration outside source control
Store the NoSQL URI, credentials, database name, environment name, and any pool or timeout settings in protected environment configuration. A service-readable file such as /etc/fastapi-app.env can contain:
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 errorsAPP_ENV=production
NOSQL_URI=engine-specific-connection-string
NOSQL_DATABASE=application_dbUse restrictive ownership and permissions on that file. Never print the URI, password, or complete connection options in startup logs or error responses.
3. Connect the NoSQL database safely
Select and install the engine’s driver
FastAPI does not choose, include, or manage a NoSQL database. Select the engine first, then install its supported Python client. The URI syntax, TLS options, authentication mechanism, asynchronous API, pool limits, retry behavior, indexes, and transaction semantics all come from that engine and its driver.
Rank #3
- 【Large size】：Measuring 800 x 300 mm/ 31. 5×12 inches, which is wider and taller than others. Large mouse pad can perfectly fit your keyboard and mouse of any size, and there is also ample space for peripherals such as phones, tablets, etc.
- 【LED backlight mouse pad】：Blade Hawks RGB mouse pad provides 7 static modes and 7 dynamic modes will give you the options you are looking for. Power-off memory function remembers the last lighting mode you selected. The super glow fiber Chroma will give you a colorful gaming setup that you want.
- 【Anti-slip rubber base】：Made from Natural rubber, this gaming mousepad will firmly grip your desktop, allowing you to enjoy the ultimate precision in the games you are most passionate about. It also comes with a texture that enhances this ability even further.
- 【Smooth and waterproof surface】: Micro-textured cloth surface, for extremely precise mouse control and a smooth movement. When liquid splashes on the gaming mouse pad, it forms water droplets and slides down. Will not delay your work or gameplay.
- 【Plug and play】: This mouse and keyboard pad is powered by USB, plug and play, no driver required. One button control light modes. Press one time to change the lighting mode, press twice to change the brightness, press and hold about 3 seconds turn ON/OFF.
Open one managed client and close it cleanly
Do not create a new database client inside every request. Create a process-level client during application startup, store it on application state, and close it during shutdown. The exact constructor and close method are driver-specific; the lifecycle pattern is:
from contextlib import asynccontextmanager
from fastapi import FastAPI, Request
@asynccontextmanager
async def lifespan(app: FastAPI):
app.state.db_client = create_client_from_environment()
app.state.database = select_database(app.state.db_client)
await verify_database_connection(app.state.database)
try:
yield
finally:
await close_client(app.state.db_client)
app = FastAPI(lifespan=lifespan)
@app.get("/health")
async def health(request: Request):
await verify_database_connection(request.app.state.database)
return {"status": "ok", "database": "reachable"}Replace the driver-specific helper calls with the selected client’s documented API. If its methods are synchronous, do not call them directly from a latency-sensitive asynchronous route; use the driver’s asynchronous interface or an appropriate worker strategy.
Separate readiness from a shallow liveness check
A process-level response only proves that Python is running. A readiness check should also test the database path when your service cannot serve useful traffic without it. Keep the check cheap, apply a timeout, and avoid returning credentials or internal connection details. During startup, a failed database check should produce a clear log entry and prevent the service from being reported ready.
Plan indexes, pooling, and backups before launch
Create indexes required by real query patterns before production traffic arrives. Set pool limits and timeouts so several API workers cannot exhaust the database’s connection budget. Document how data is backed up, how long backups are retained, and how a restore is tested. These choices cannot be inferred from FastAPI; they must follow the selected NoSQL engine and its operational tooling.
4. Run a first smoke test on the VPS
Run the application on a loopback address and a high, unprivileged port before adding Nginx:
cd /srv/fastapi-app
. .venv/bin/activate
uv run uvicorn app.main:app --host 127.0.0.1 --port 8000From another shell on the VPS, call the health endpoint and exercise at least one database read and one write path:
Rank #4
- 【Softer and More Comfortable】Vaydeer wrist rest has unique diamond pattern, which is the combination of softness and aesthetics. The materials of wrist rest are improved into higher quality memory foam and covered with silky smooth lycra. The computer wrist rest makes you as comfortable and cushiony as like rest your wrists on clouds.
- 【Ergonomic Wrist Saver】The wrist rests for keyboard and mouse comes with a 17.32×3.15×0.83 inch keyboard wrist pad and a 5.94×3.15×0.83 inch mouse wrist support. Based on ergonomic design, the unique concave shape is the perfect fit for your wrist joints. The wrist rest pad fits most computer keyboards and laptops, improve hand and wrist posture, release your wrist and arm stress.
- 【Non-Slip Rubber Bottom】Featuring an anti-skid silicone base on the bottom, this wrist keyboard support stays firmly in place on your desk, preventing the padding from sliding around, ensuring stable and consistent wrist support during extended computer sessions.
- 【Better Experience & Pain Relief】Our keyboard arm rest is beneficial to alleviate the soreness caused by direct contact and friction between your arm and a hard desk surface, reducing the risk of wrist fatigue or carpal tunnel. The soft texture of memory foam can evenly distribute the pressure around your wrists and provide good support with just enough give.
- 【Helpful in Multiple Scenarios】Whether you're working, studying, writing, typing, gaming, this keyboard and mouse rest combo is an essential accessory to add comfort and support to your hands and wrists. It’s also a great gift for men, women, family, friend, coworker, gamer, teacher, etc.
curl http://127.0.0.1:8000/healthInspect the application output for import errors, authentication failures, timeout messages, and connection-pool warnings. Stop this foreground process after the smoke test. Do not use --reload here as a substitute for production supervision.
5. Add production process supervision
Understand the server roles
| Mode | Use | What it does not provide |
|---|---|---|
uvicorn --reload |
Local development and rapid code iteration | Stable production supervision or a public TLS boundary |
| Uvicorn without reload | Simple foreground or tightly controlled service runs | Worker coordination and restart policy by itself |
Gunicorn with uvicorn.workers.UvicornWorker |
Production process management with multiple worker processes | Public proxying and TLS; Nginx or another trusted proxy still handles those concerns |
Start with a conservative worker count. Every worker has Python memory overhead and may create its own database pool. A higher count is not automatically faster on a small VPS; measure memory, response behavior, and database connection usage before increasing it.
Create a systemd service
Install Gunicorn in the virtual environment, then create a unit such as /etc/systemd/system/fastapi-app.service:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
[Unit]
Description=FastAPI application
After=network-online.target
Wants=network-online.target
[Service]
User=fastapi-app
Group=fastapi-app
WorkingDirectory=/srv/fastapi-app
EnvironmentFile=/etc/fastapi-app.env
ExecStart=/srv/fastapi-app/.venv/bin/gunicorn
--workers 2
--worker-class uvicorn.workers.UvicornWorker
--bind 127.0.0.1:8000
--forwarded-allow-ips 127.0.0.1
app.main:app
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.targetThe two-worker value is a starting example, not a benchmark or universal recommendation. Change it after checking the VPS’s available memory and the database’s connection limits. If Nginx connects through a Unix-domain socket instead, use that socket as the bind target and allow only the appropriate service users to access it.
Load and start the unit:
sudo systemctl daemon-reload
sudo systemctl enable --now fastapi-app
sudo systemctl status fastapi-app
sudo journalctl -u fastapi-app -fConfirm that a deliberate stop and start behaves as expected, and later test the configured failure-restart policy. Keep logs in the journal or another controlled destination rather than writing unbounded files in the application directory.
6. Put Nginx in front of the application
Nginx should be the public listener while Uvicorn remains on loopback or a private socket. This gives you one place for TLS, access and error logs, request-size limits, timeouts, and proxy headers.
Best Value
- 【No Drill Mounted】Cable management tray can be assembled in as little as 3 minutes or less-simply. Side clips easily clampe the edge of desk, pass through the holes on the sides, and secure excess cables with baskets. Desk cable management supports inward or outward installation to meet your needs in different scenarios, and provides you with great convenience when collecting and organizing wires.
- 【Rubber Pad Protects Desk】Wire organizer under desk built-in soft rubber pads on the clamp protect your desk from scratches, so you will not damage your furniture or office.
- 【Sturdy and Beautiful】Cord management under desk is made of high-quality carbon steel and holds about 15 lbs. The wire basket has 2 holes on each side of the tray to enable your cables to pass freely. Cable baskets are suitable for desk thickness use from 0.4" to 2.4".
- 【Space Saving & Keep Organized】Desk cable management tray holds all your power cords, outlet strips, USB hubs and computer transformers hidden from your feet, and the data cables will not enter the vacuum cleaner to keep your desk clean and tidy. Desk wire organizer is also suitable for use in the kitchen and outdoors.
- 【Reduce Safety Risks】Cable tray under desk keeps all plugs away from your kids, no more worry about tripping. Using 2 holes wire tray saves extra space, helps you easily cabling and wire protection. The mesh design is not easy to accumulate dust, but avoids safety accidents caused by messy wires.
A minimal server block for an HTTP-to-application path is:
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 →Scan for outdated or missing drivers - takes under a minuteDriver Scan →server {
listen 80;
server_name api.example.net;
client_max_body_size 10m;
location / {
proxy_pass http://127.0.0.1:8000;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_read_timeout 60s;
}
}Replace the hostname and limits with values appropriate for your API. Keep request-size and timeout settings intentional: a large upload limit or very long timeout can consume scarce memory and worker capacity. Add WebSocket upgrade headers only if the application actually uses WebSockets.
After validating the configuration with your distribution’s Nginx test command, reload Nginx without stopping active connections. Confirm that the public request reaches the application and that the application logs show the expected host and scheme.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.7. Enable HTTPS and handle forwarded headers
Terminate TLS at the trusted proxy
Use Nginx or another trusted proxy to terminate TLS with a certificate service such as Let’s Encrypt. The proxy handles the encrypted client connection; Nginx then forwards an HTTP request to the local application. This is expected, but it means the application must receive accurate forwarded scheme and address headers.
Redirect plain HTTP to HTTPS after the certificate is working. Keep the certificate renewal process under supervision and verify renewal before the first certificate approaches expiration.
PC 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 & 11Crashes, 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 minuteTrust forwarded headers only from the real proxy
X-Forwarded-For, X-Forwarded-Proto, and X-Forwarded-Host affect client-address logging, URL generation, redirects, and security decisions. They are trustworthy only when the connecting peer is your proxy. Uvicorn’s forwarded-allow list should contain the actual proxy address or socket peers, not an unrestricted wildcard.
For the loopback Nginx arrangement above, --forwarded-allow-ips 127.0.0.1 limits trust to the local proxy. If a load balancer or private proxy connects from another address, replace that value with the real, restricted address range and document why it is trusted. Never allow arbitrary internet clients to supply trusted forwarding headers directly.
8. Verify the complete path
Test in layers so a failure has a narrow search area:
- Call Uvicorn locally on its loopback port and verify the health endpoint.
- Verify a database read and write using production-like credentials and the expected database name.
- Stop the service and confirm systemd starts it again when configured to do so.
- Call Nginx locally and verify that it proxies to the same application response.
- Call the public HTTPS hostname and inspect the certificate, redirect behavior, response status, and application logs.
- Confirm that logs record the real client address and HTTPS scheme without accepting spoofed headers from untrusted peers.
- Exercise representative payload sizes, slow queries, validation errors, and authentication failures.
Do not treat “the process is listening” as completion. Production readiness also includes startup after reboot, restart behavior, HTTPS, logging, database reachability, capacity, backups, and a recovery procedure.
Free tools Windows power users keep installed
One-click scans. No signup required.
Quick Recap
9. Operational safeguards for the NoSQL service
- Network exposure: keep a local database bound privately, or restrict a remote database to the application’s private network or source address.
- Credentials: use a dedicated database identity with only the permissions the API needs; rotate it through protected configuration rather than source changes.
- Backups: define backup frequency, retention, encryption, and a restore test. A backup that has never been restored is an assumption, not a recovery plan.
- Indexes: review slow-query logs and add indexes for actual access patterns. Remove obsolete indexes that consume write and storage capacity.
- Capacity: watch VPS memory, disk usage, worker count, pool usage, and database limits. Leave headroom for deploys and recovery operations.
- Failure behavior: set finite connection and operation timeouts, decide how the API responds when the database is unavailable, and avoid retry loops that multiply load during an outage.
Choosing a topology
| Choice | Advantages | Trade-offs |
|---|---|---|
| Application and NoSQL database on one VPS | Few moving parts and a private local connection | Shared CPU, memory, disk, and failure domain; you maintain both services |
| Application on the VPS, database on a managed or separate private service | Database maintenance and scaling can be separated from the API host | Network dependency, separate access controls, and service-specific operational policies |
| Uvicorn directly under a supervisor | Simple process layout for a very small service | Fewer worker-management features than a Gunicorn/Uvicorn-worker setup |
| Gunicorn with Uvicorn workers | Production-oriented worker processes and restart coordination | Each worker consumes resources and may open its own database connections |
| Nginx terminates TLS on the VPS | Direct control over certificates, headers, logs, and limits | You own proxy configuration and certificate renewal |
| External load balancer or proxy terminates TLS | Can provide an external edge and distribute traffic across hosts | More network layers, forwarded-header configuration, and provider-specific operations |
Troubleshooting by symptom
The service exits immediately
- Run the exact
ExecStartcommand as the service user fromWorkingDirectory. - Check that the module path and object name match the import string, such as
app.main:app. - Inspect
journalctl -u fastapi-appfor missing dependencies, invalid environment variables, or permission errors.
Nginx returns 502 Bad Gateway
- Check that systemd reports the API as active and that something is listening on
127.0.0.1:8000or the configured socket. - Compare Nginx’s
proxy_passtarget with Gunicorn’s--bindtarget. - Read both Nginx’s error log and the application journal; a database startup failure can make the upstream process unavailable.
The API reports the wrong scheme or client address
- Confirm Nginx sends the forwarded headers.
- Confirm Uvicorn trusts only the address of Nginx or the known upstream proxy.
- Check that clients cannot connect directly to the application listener and inject their own forwarding headers.
Database requests time out
- Verify the URI, credentials, database name, DNS, routing, firewall rules, and TLS requirements.
- Check whether worker count and pool limits exceed the database’s connection allowance.
- Inspect database health and slow-query information rather than increasing timeouts blindly.
The VPS runs out of memory
- Reduce worker count and pool limits temporarily, then measure again.
- Check database memory use, Nginx request limits, large response bodies, and unbounded background work.
- Add capacity or move the database only after identifying which component is consuming memory.
Deployment completion checklist
- The API runs as a non-root user from an isolated virtual environment.
- FastAPI exposes an importable application object and production runs without reload mode.
- Gunicorn uses Uvicorn workers under systemd, starts at boot, and restarts after a tested failure.
- Nginx is the public listener; the application listener is private.
- HTTPS is active, renewal is planned, and redirects behave correctly.
- Forwarded headers are trusted only from known proxy addresses.
- NoSQL credentials are protected, the database is not publicly exposed, and the driver client closes during shutdown.
- Readiness checks cover the database path when database access is required to serve traffic.
- Indexes, pool limits, backups, retention, restore testing, logs, and capacity alerts are documented for the selected NoSQL engine.
- A reboot, restart, database outage, malformed request, and representative production request have all been tested.
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.
