Find ASP.NET Core services running under systemd
Finding an application on a Linux server means identifying the service that owns its process, not guessing from a domain name. On a shared Ubuntu machine, deployment folders, service units and public websites can all use different names.
Server App Manager includes a discovery step for recognizable .NET services. This guide explains how to review its results, what the current scan can miss, and when manual verification is necessary. All service names and addresses below are examples for an isolated lab.
Begin with the application owner
Before scanning, decide which applications you are responsible for. A list of services is not a grant of permission to manage every item in it.
Ask the owner for the expected application, environment and service identity where those are known. Record whether it is a public website, an internal HTTP application or a background worker. That context helps you interpret a missing website URL or listening port.
For a lab, use a unit such as demo-web.service and a separate worker unit. Keep the expected mapping in a short note. The exercise succeeds when the discovered information agrees with that mapping, not merely when the scan returns a long list.
Know what the current discovery recognizes
The source preview scans loaded systemd service information for recognizable .NET launch patterns. It can identify a direct dotnet launch and an executable with a neighboring runtime configuration file.
These patterns are useful clues rather than a complete application inventory. A shell wrapper, custom launcher, unusual deployment layout or inaccessible file can prevent recognition. A service may also exist on disk without appearing as the kind of loaded unit the scan considers.
The application README describes current recognition behavior. Check that behavior against the revision you are evaluating instead of assuming every future .NET hosting model is covered.
Keep the names separate
A friendly display name is for people. The systemd unit name identifies the management target. A deployment directory locates files. The assembly name identifies an application artifact. None of these fields automatically determines the public hostname.
For example, a lab registry entry might have the display name “Demo website — test” and the unit demo-web.service. Its public address could be https://web.example.com, while the process listens on a local application port.
Do not normalize these fields by making them all resemble the website name. Preserve the real unit identity and use the friendly display name to make the list easier to read.
Open Find apps and inspect a candidate
Sign in to the local dashboard with your verified SSH registration. Open Applications and choose Find apps.
Look at a candidate's service name and any available path, assembly and port information. Decide whether it corresponds to an application you intend to manage. If two entries have similar names, compare their environment and deployment details before opening the registration form.
Choose Review and add for one candidate. The review step is intentional: it gives you a chance to correct a display name, add a known public URL and reject an unrelated unit. Discovery does not silently enroll every result.
Verify the canonical unit
A canonical unit name is the identity systemd reports for the loaded service. The dashboard validates the service before saving a registration and before management operations.
If you need independent inspection in an authorized lab, a read-only command can request the relevant identity and state:
systemctl show demo-web.service -p Id -p LoadState -p ActiveState -p MainPID
The displayed values are evidence to compare, not sample values to copy into the registry. A missing unit, an alias and a loaded canonical service are different cases. The systemctl manual documents inspection commands and the distinction between loaded units and installed unit files.
Treat detected ports as observations
A listening port is a point-in-time observation of a socket visible to the account. It may not be available when a service is stopped or starting. Some services open several sockets; a worker may open none.
A port detected during discovery should therefore be checked against the intended application. If it is missing, investigate before filling it with a number remembered from another deployment.
A registry port is useful operational metadata, but it does not edit Kestrel or the proxy configuration. Changing that field alone cannot move an existing service to another listener. Keep the dashboard's metadata aligned with verified server configuration.
Add the website URL deliberately
For a public website, enter its actual HTTP or HTTPS URL. The dashboard's health checker uses that address from your PC.
An internal listener and the public site can differ because Nginx handles the public connection. Likewise, several public routes can reach a shared application. A valid local port does not prove that a particular public URL maps to that unit.
Leave unrelated website assumptions out of worker registrations. If your application has no appropriate public endpoint, understand that limitation rather than adding a random homepage to obtain a green health indication.
Save one application and inspect its state
After reviewing the fields, save the registration and return to Applications. Open its status and recent logs before using a management button.
Confirm that the displayed unit remains the one you reviewed. Check the main PID and available service memory. If the process is stopped, those readings can be unavailable; a missing current PID is not a reason to fabricate a value.
Look at the last-check time and refresh after a known state change. The dashboard caches status information between sampling intervals, so it represents a recent observation rather than a continuous stream of every process transition.
Use manual registration for a verified exception
A wrapper-based application can still be manageable even when automatic discovery cannot recognize its .NET runtime. Verify its canonical systemd unit with the server owner, then use the manual registration facility.
Keep deployment metadata factual. If the assembly name does not apply to a native app host, do not invent one for consistency. The management boundary is the validated service unit, while supplementary fields help an operator understand what it represents.
A useful discovery bug report describes the launch pattern with private paths and arguments removed. Full launch commands can contain configuration details, so share only what is necessary to reproduce the recognition problem.
Organize the list for everyday use
Use distinct environment labels and display names when applications share a business name. Put frequently used services near the top through display order.
An enabled setting and removal serve different purposes. Disabling retains the entry for later use. Removing unregisters it from the local dashboard and records the change; it does not uninstall the application.
If another operator maintains a registry on another PC, remember that these are local registrations. A rename in your list is not a server-side rename, and removing an entry from your dashboard does not remove the corresponding entry from someone else's local state.
Check a framework-dependent and an executable deployment
For a reproducible lab review, compare two existing sample services: one that starts with dotnet and one that launches an app executable beside its runtime configuration file.
Record what the scan recognized, whether the service was loaded, which listening port was visible, and what you verified manually. Do not assume both services should expose an HTTP endpoint.
The .NET deployment guide describes deployment forms, while the dashboard application guide describes its registry and controls. Keep these two layers separate when explaining a discovery result.
Define a completed discovery review
A complete result is an accurate local entry for a known service, with a verified identity and honest supplementary metadata. It includes an understanding of what remains unknown.
For your first session, register one application and prove that its status and logs match the expected service. Add the next application only after that workflow is clear. This small review discipline prevents a convenient discovery screen from becoming an unverified list of production controls.