When Nginx will not start on Ubuntu, do not begin by repeatedly restarting it. First capture systemd’s failure details, then run sudo nginx -t. That test checks Nginx syntax and attempts to open files named by the configuration, so its first concrete error usually identifies the repair: a bad directive or include, a missing or unreadable certificate, or a port already owned by another process. Correct that error, run the test again, and only then restart or reload Nginx.
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 safe repair sequence
Use this order so that each command answers a different question and you do not hide the original failure. Run the commands from a shell account that can use sudo.
As an Amazon Associate I earn from qualifying purchases.
- Capture the unit summary. Run
sudo systemctl status nginx. Look for the active state, the exit status, the command systemd attempted, and the last few log lines. - Read the complete service journal. Run
sudo journalctl -xeu nginx.service. The journal often includes a more specific reason than the short status display, such as the file and line that prevented startup. - Run the decisive pre-start test. Execute
sudo nginx -t. NGINX defines-tas a syntax check followed by an attempt to open files referenced by the configuration. Ubuntu’s main configuration file is normally/etc/nginx/nginx.conf; a failed test returns exit status 1. - Repair the first reported error. Fix the directive, include, path, permission, certificate, key, or listener named by the test. Do not jump to a later message while the first error remains.
- Retest. Run
sudo nginx -tagain after every correction. Continue until it reports that the configuration syntax is OK and the test is successful. - Inspect Nginx’s own error log. Debian and Ubuntu packages commonly write to
/var/log/nginx/error.log. Confirm the actual path withnginx -V, because package builds can use different compile-time locations. - Apply the validated configuration. Use
sudo systemctl restart nginxwhen the service is stopped or you need a full restart. If the master process is already running, a graceful reload applies a successful configuration without stopping existing workers;sudo nginx -s reloadis the direct Nginx form. - Verify both the service and HTTP. Run
sudo systemctl status nginx, thencurl -I http://127.0.0.1/. If the server is meant to be public, test the configured hostname from an appropriate client as well.
What each failure message means
| Evidence | What it establishes | Next action |
|---|---|---|
Job for nginx.service failed |
systemd could not bring the unit into its requested running state. It is a summary, not the root cause. | Read systemctl status and journalctl -xeu nginx.service, then run nginx -t. |
nginx: configuration file /etc/nginx/nginx.conf test failed |
The configuration test returned a failure, normally because syntax or a referenced file could not be validated. | Use the first file-and-line error printed by sudo nginx -t. |
syntax is ok followed by a successful test message |
Nginx accepted the syntax and opened the files it checks. This is the prerequisite for applying the configuration. | Restart or reload, then verify the unit and an HTTP response. |
bind() ... failed or an address already in use message |
Another process, or another Nginx listener, owns the configured address and port. | Inspect listeners with sudo ss -ltnp and reconcile the listen directives. |
| Cannot open certificate, key, include, or other file | The path is missing, wrong, or unreadable by the process that starts Nginx. | Check the path, existence, ownership, and mode; correct it and retest. |
| The test succeeds but systemd still fails | The configuration is not the remaining blocker. Unit overrides, executable paths, PID paths, or package state may differ from the command you tested. | Use the full journal and nginx -V to compare the service’s paths and binary with your test environment. |
Read the service-manager evidence before changing anything
systemctl status nginx
The status view is the fastest way to see whether the unit is active (running), failed, activating, or repeatedly restarting. It also shows the most recent process exit and a short tail of the journal. Save or copy this output before running a restart; a new attempt can move the useful lines out of the short view.
journalctl -xeu nginx.service
The journal command asks systemd for extended, explanatory entries for the Nginx unit. Read from the first error that appears in the current start attempt. Messages about a configuration test, a failed bind, a missing file, or a permission denial are more actionable than the final “failed” state. If the output is long, use the terminal’s search function for error, failed, bind, permission, certificate, and include.
#1 Best Overall
Use nginx -t as the decision point
The -t option is not merely a parser check. NGINX documents that it checks configuration syntax and then tries to open files referred to by the configuration. That is why it catches an absent TLS certificate, an unreadable key, or a missing include before a restart takes the service down. The command exits with status 1 when the test fails, which also makes it suitable for scripts and deployment checks.
Run it exactly as the service administrator would:
sudo nginx -tRead the complete output, including the file name and line number. The main file is normally /etc/nginx/nginx.conf, but that path can be changed by a package build or command-line option. Confirm the compiled paths and options with:
nginx -VDo not restart after a failed test. A restart simply asks systemd to launch the same invalid configuration again and can turn a recoverable configuration edit into an avoidable outage.
Repair syntax, includes, and conflicting declarations
Malformed directives and braces
A syntax error generally names the file and line where Nginx noticed the problem. Inspect that line and the block around it, because the actual mistake can be an unmatched brace or a missing semicolon on the preceding line. Correct the smallest possible change, save the file, and rerun sudo nginx -t.
Include files
An include directive can pull in a file or a wildcard of files. A typo in the path, a deleted file, or an invalid directive inside one of those files makes the overall test fail. Follow the path printed in the error rather than assuming every site definition lives in the same directory. If a wildcard is intended to match optional files, verify that the configuration actually uses a pattern that behaves as expected; do not silently remove an include just to make the test pass.
Rank #2
Duplicate or contradictory settings
Multiple server blocks can be valid, but contradictory declarations can produce an error or select an unintended listener. When the test identifies a duplicate or conflicting declaration, inspect every included file that defines the same directive. Keep one deliberate value for the affected server or listener, then retest.
Check referenced files and permissions
Because nginx -t attempts to open referenced files, its errors provide a direct branch for missing assets. Common examples include TLS certificates and keys, include files, and paths used by a server block. For each path named in the output:
- Confirm the spelling and absolute path in the configuration.
- Confirm that the file exists at that path.
- Confirm that every directory in the path can be traversed by the account that starts Nginx.
- Confirm that the file is readable under the intended ownership and mode. A private key should not be made broadly readable merely to bypass an error.
- Retest immediately after the correction.
TLS certificates and keys
A certificate or key path that worked previously can fail after a renewal, a move, a permissions change, or a configuration edit. Check both paths named by the ssl_certificate and ssl_certificate_key directives, and make sure the configured files are the ones you intend to serve. If the error says the file cannot be opened, fix the path or access rights first; do not replace the file with a guessed location.
Document roots and other paths
Some referenced paths are directories rather than files. A wrong root or an inaccessible directory may not produce the same message as a missing certificate, but the remedy is still evidence-led: use the exact path Nginx reports, verify it exists, and correct ownership or mode without weakening access controls unnecessarily.
Find a port 80 or 443 conflict
Nginx cannot bind a configured listen address when another process already owns that socket. Port 80 is the usual HTTP listener and port 443 is the usual HTTPS listener, but use the addresses and ports in your own server blocks as the source of truth.
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 →- List listening TCP sockets and their owning processes with
sudo ss -ltnp. - Compare the local address and port in the output with every
listendirective in the Nginx configuration and its includes. - Identify the owner. It may be another web server, a second Nginx master, a development service, or a container-forwarded process.
- Choose one deliberate fix: stop or reconfigure the competing service, move Nginx to an available address or port, or remove the duplicate Nginx listener.
- Run
sudo nginx -tagain before starting anything.
Do not stop a process solely because it owns port 80 or 443. Confirm what it provides and whether another application depends on it. A successful configuration test can still be followed by a bind failure at startup if the competing process appears between the test and restart, so verify the listeners again when the journal reports a conflict.
Use the Nginx error log for runtime detail
The systemd journal explains why the unit transition failed; Nginx’s error log can add module- and worker-level context. Debian and Ubuntu packages commonly use /var/log/nginx/error.log. The configured error_log directive determines the actual destination, and nginx -V helps confirm package-specific paths and build options.
Read entries from the same minute as the failed start and match their timestamps to the journal. Distinguish a startup error from an unrelated request error left over from an earlier run. If the expected log is empty or absent, use the configured error_log locations and the journal rather than creating a new log path at random.
Choose restart or graceful reload
Full restart
Use:
sudo systemctl restart nginxA restart stops and starts the service through systemd. It is appropriate after a failed start, after changing service-level settings, or when the master process is not running. It should follow a successful nginx -t.
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 errorsGraceful reload
When the Nginx master is already running, a reload applies a validated configuration while allowing existing workers to finish current work:
sudo nginx -s reloadThe Nginx beginner guidance treats reload as the normal way to apply configuration changes. Microsoft’s Ubuntu guidance likewise pairs a successful sudo nginx -t with sudo nginx -s reload. If the master is stopped or systemd reports a failed unit, use the systemd restart path instead.
When nginx -t passes but systemd still fails
A successful test proves that the command you ran accepted the configuration and could open the files it checked. It does not prove that systemd is invoking the same binary, environment, unit file, or PID path. Return to the complete journal and compare the service definition with the command-line environment.
Check executable and configuration paths
Run nginx -V and note the binary, configuration, log, and PID-related compile-time options. Compare those paths with the command shown in systemctl status nginx and the unit’s journal. A custom installation can test one binary while the service starts another.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Inspect unit overrides
Systemd drop-in overrides can change the start command, user, environment, PID file, or restart policy. If the journal reports an unexpected executable, option, or PID location, inspect the unit and its overrides before editing Nginx configuration. Correct the override or restore the intended package unit, then reload systemd’s unit definitions as appropriate for that change and retest.
Check PID and runtime paths
If the journal reports that a PID file cannot be created, read, or found, compare the configured PID path with the service’s expected path and directory permissions. Remove only a demonstrably stale runtime artifact; do not delete a live PID file while an Nginx master is running.
Consider package integrity
If syntax, files, sockets, and unit paths all check out, the remaining evidence may point to a damaged or mismatched package installation. Use the journal to identify the executable or library that fails and compare the installed package files with the distribution’s package state before replacing anything. Keep the known-good configuration backed up so a package repair does not erase the change that caused the issue.
Verify the recovery
Service state
Run:
sudo systemctl status nginxLook for active (running) and a recent start time. A command that returns successfully is not enough if the unit immediately enters a failed or restarting state.
Recommended Free Tools
Local HTTP response
Ask the local listener for headers:
curl -I http://127.0.0.1/An HTTP response confirms that a process is accepting local requests. The response status and headers also help distinguish Nginx from another service that might have claimed the port.
Public hostname
If DNS, firewall rules, and a public address are part of the deployment, request the configured hostname from outside the server as well. A local success proves the service is listening locally; it does not prove that DNS, routing, firewall policy, TLS termination, or the selected server block is correct.
A compact decision checklist
- Service failed: capture
systemctl status nginxandjournalctl -xeu nginx.service. - Configuration test failed: fix the first file-and-line error, then rerun
sudo nginx -t. - File error: verify the exact path, existence, traversal, ownership, and read permission.
- Bind error: run
sudo ss -ltnp, identify the owner, and resolve the listener conflict deliberately. - Test succeeds: restart a stopped service or gracefully reload a running master.
- Service is active: check
curl -I http://127.0.0.1/and then the public hostname when applicable. - Test succeeds but startup fails: compare systemd’s executable, configuration, PID, and unit overrides with
nginx -Vand the journal.
Prevent the next failed start
Make sudo nginx -t a gate before every configuration deployment, certificate replacement, or include-file change. Keep edits small enough that the first failing line is obvious, and retain the previous known-good file until the new test succeeds. When a change is applied to a running service, prefer a graceful reload after the test rather than an unnecessary stop/start cycle. If the test fails, preserve the exact error output and correct that branch before investigating unrelated warnings.
The practical rule is simple: systemd tells you that Nginx failed, nginx -t tells you whether the configuration and its referenced files can be accepted, the error log and journal explain the context, and ss identifies socket ownership. Following those evidence paths prevents guesswork and gets the service back only after the underlying cause is fixed.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchQuick 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.
