Adios
Apps and APIs · plans from $10/month

Deploy .NET.Publish once. Run the reviewed output.

Build a release artifact with dotnet publish, start the selected assembly, verify application health, and keep the route connected to the source version.

Deploy my projectDeploy a template
Keep the repositoryInspect build and logsCustom domains and TLS
Adios deploy

Candidate release

.NET

Healthy

SOURCE

Git

REGION

de

ROUTE

HTTPS

01Source received

02Build completed

03Runtime started

04Health check passed

Promoted route

production.adios.run

A production path for

.NET 8C#ASP.NET CoreBlazorMinimal APIs

The production path

A working .NET project still needs a safe release.

The application or service is only one part of production. Build evidence, runtime state, health, secrets, logs, routes, and the promoted version should remain inspectable together.

Keep the .NET build you already use

Use dotnet restore and dotnet publish with the project or solution already in Git. The output directory becomes the artifact started by the release.

Promote the version that reports healthy

Set ASPNETCORE_URLS or the equivalent binding, expose a health endpoint, and inspect startup configuration before the candidate becomes current.

Trace production back to source

Build output, runtime logs, health state, secrets, domains, and the promoted release stay attached to the project instead of being split across unrelated tools.

From source to release

Three steps keep the deployment path reviewable.

Use the source and production behavior the project already has. The manifest records what the platform should build or provision and how the result becomes ready.

  1. 01

    Start with source or a template

    Bring the existing repository, or inspect and deploy one of the exact starter variants linked below.

    $adios login
  2. 02

    Review the deployment contract

    Keep commands, runtime or service version, health behavior, and secret references in adios.yaml.

    $git diff -- adios.yaml
  3. 03

    Deploy and inspect the result

    Follow build and runtime evidence, verify the candidate, and open the promoted route or service connection.

    $adios up
adios.yaml
Your project
name: dotnet-api
build_cmd: dotnet publish -c Release -o out
start_cmd: dotnet out/MyApp.dll

runtime:
  name: dotnet@8
  port: 8080
  health_path: /healthz
Replace MyApp.dll with the assembly emitted by your project and keep the runtime version aligned with its target framework.

Deployable starting points

Start .NET from a template when the repository is not ready.

Compare ASP.NET Core, Minimal API, and Blazor starters with their exact publish and start paths already visible.

API starters

ASP.NET Core

ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core, and .NET 8 starters.

C#.NET CLI
Template key
dotnet-aspnet-core
Runtime
dotnet
Repository
templates
Source path
dotnet/aspnet-core
git clone https://github.com/adiosdotdev/templates.git
cd templates/dotnet/aspnet-core
adios up
DeployView source

API starters

.NET FastEndpoints

ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core, and .NET 8 starters.

C#.NET CLI
Template key
dotnet-fastendpoints
Runtime
dotnet
Repository
templates
Source path
dotnet/fastendpoints
git clone https://github.com/adiosdotdev/templates.git
cd templates/dotnet/fastendpoints
adios up
DeployView source

API starters

.NET 8 Minimal API

ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core, and .NET 8 starters.

C#.NET CLI
Template key
dotnet
Runtime
dotnet
Repository
templates
Source path
dotnet/8.0
git clone https://github.com/adiosdotdev/templates.git
cd templates/dotnet/8.0
adios up
DeployView source

API starters

.NET Blazor

ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core, and .NET 8 starters.

C#.NET CLI
Template key
dotnet-blazor
Runtime
dotnet
Repository
templates
Source path
dotnet/blazor
git clone https://github.com/adiosdotdev/templates.git
cd templates/dotnet/blazor
adios up
DeployView source

API starters

.NET ABP Framework

ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core, and .NET 8 starters.

C#.NET CLI
Template key
dotnet-abp
Runtime
dotnet
Repository
templates
Source path
dotnet/abp
git clone https://github.com/adiosdotdev/templates.git
cd templates/dotnet/abp
adios up
DeployView source

API starters

.NET Orchard Core

ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core, and .NET 8 starters.

C#.NET CLI
Template key
dotnet-orchard-core
Runtime
dotnet
Repository
templates
Source path
dotnet/orchard-core
git clone https://github.com/adiosdotdev/templates.git
cd templates/dotnet/orchard-core
adios up
DeployView source
Read the .NET deployment guide

Before production

Verify the workload.Then promote it.

The safest first release starts with a reproducible build or service configuration and a preview that exercises the dependencies production will actually use.

Ready when…

  • dotnet publish succeeds from a clean checkout.
  • The emitted assembly starts without an IDE profile.
  • The app listens on the configured production URL and port.
  • Connection strings and signing keys use secrets.

Preview when…

  • The solution uses native or platform-specific dependencies.
  • Entity Framework migrations change production data.
  • Blazor or WebSocket connections need release testing.

Questions, answered

What to know before deploying .NET.

Review the runtime or service boundary, template path, failure behavior, and production checks before creating the first release.

Can Adios deploy an existing .NET project?

Yes. Run the Adios CLI from the project root, keep the repository and dependency files you already use, and add an adios.yaml file that describes the production build, start command, port, and health path.

Do I need Docker to deploy .NET?

Not for a standard supported runtime. Use the project's normal production commands in adios.yaml. If the build needs unusual operating-system packages or native libraries, verify those dependencies in a preview before promotion.

Which .NET templates are available?

The catalog includes ASP.NET Core, FastEndpoints, .NET 8 Minimal API, Blazor, ABP Framework, and Orchard Core variants.

Can I deploy a framework-dependent .NET build?

Yes, when the selected Adios runtime matches the target framework. Keep the publish output and start assembly explicit, then verify required native libraries in a preview.

What happens when the build or health check fails?

The candidate release keeps its build and runtime output for inspection. It must report healthy before it becomes the promoted version serving the application route.

Can I start from a template instead of an existing repo?

Yes. This page links to the closest official Adios .NET starters. Inspect the exact source variant, deploy it in the console, or clone it locally and run adios up.

Related deployment paths

Connect the rest of the stack.

Browse all deployment pages

Deploy ASP.NET Core

Build an ASP.NET Core release artifact, bind Kestrel to the production port, verify health, and connect configuration, logs, domains, and TLS.

Deploy PostgreSQL

Choose a PostgreSQL version, keep database credentials out of Git, attach persistent storage, connect the application, and verify data after a restart.

Deploy Redis

Start Redis 7 for cache, session, pub/sub, or fast state workloads, then verify connectivity, persistence expectations, eviction, and dependency failure behavior.

Deploy Adios workflows

Deploy scheduled jobs, webhook processors, approval gates, maintenance tasks, and operational automation from a versioned workflow manifest.

The first release

Deploy .NET with the source and evidence attached.

Start from the repository or a template, review the deployment contract, and inspect what becomes the promoted production version.

Start with AdiosCompare plans