Adios
IT
App e API · piani da $10/mese

Distribuisci .NET.Pubblica una volta. Esegui l'output verificato.

Crea un artefatto di rilascio con dotnet publish, avvia l'assembly scelto, verifica l'integrità dell'applicazione e mantieni la route collegata alla versione del codice sorgente.

Distribuisci il mio progettoDistribuisci un template
Mantieni il repositoryEsamina compilazione e logDomini personalizzati e TLS
Distribuzione con Adios

Versione candidata

.NET

Stato regolare

SORGENTE

Git

REGION

de

ROUTE

HTTPS

01Codice sorgente ricevuto

02Compilazione completata

03Ambiente di esecuzione avviato

04Controllo di integrità superato

Route promossa

production.adios.run

Un percorso verso la produzione per

.NET 8C#ASP.NET CoreBlazorMinimal APIs

Il percorso di produzione

Un progetto .NET funzionante ha ancora bisogno di un rilascio sicuro.

L'applicazione o il servizio è solo una parte della produzione. Le evidenze della compilazione, lo stato dell'ambiente di esecuzione, l'integrità, i segreti, i log, le route e la versione promossa devono restare consultabili insieme.

Mantieni la compilazione .NET che usi già

Usa dotnet restore e dotnet publish con il progetto o la soluzione già in Git. La directory di output diventa l'artefatto avviato dal rilascio.

Promuovi la versione che supera i controlli di integrità

Imposta ASPNETCORE_URLS o il binding equivalente, esponi un endpoint di integrità ed esamina la configurazione di avvio prima che la versione candidata diventi quella attuale.

Risali dalla produzione al codice sorgente

Output della compilazione, log di esecuzione, stato di integrità, segreti, domini e versione promossa restano associati al progetto, senza essere sparsi tra strumenti indipendenti.

Dal codice sorgente al rilascio

Tre passaggi mantengono il percorso di distribuzione verificabile.

Usa il codice sorgente e il comportamento di produzione già previsti dal progetto. Il manifesto indica cosa la piattaforma deve compilare o provisionare e come verificare che il risultato sia pronto.

  1. 01

    Parti dal codice sorgente o da un modello

    Porta il repository esistente oppure esamina e distribuisci una delle varianti dei modelli iniziali indicate nei link qui sotto.

    $adios login
  2. 02

    Verifica il contratto di distribuzione

    Mantieni in adios.yaml i comandi, la versione dell'ambiente di esecuzione o del servizio, il comportamento dei controlli di integrità e i riferimenti ai segreti.

    $git diff -- adios.yaml
  3. 03

    Distribuisci e verifica il risultato

    Segui le evidenze della compilazione e dell'esecuzione, verifica la versione candidata e apri la route promossa o la connessione al servizio.

    $adios up
adios.yaml
Il tuo progetto
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
Sostituisci MyApp.dll con l'assembly generato dal progetto e mantieni la versione dell'ambiente di esecuzione allineata al framework di destinazione.

Punti di partenza pronti per la distribuzione

Avvia .NET da un modello quando il repository non è pronto.

Confronta i modelli iniziali ASP.NET Core, Minimal API e Blazor, con i percorsi esatti di pubblicazione e avvio già visibili.

Progetti base API

ASP.NET Core

Progetti base ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core e .NET 8.

C#.NET CLI
Chiave modello
dotnet-aspnet-core
Ambiente di esecuzione
dotnet
Repository
template-dotnet-aspnet-core
Percorso sorgente
.
git clone https://github.com/adiosdotdev/template-dotnet-aspnet-core.git
cd template-dotnet-aspnet-core
adios up
DistribuisciVisualizza sorgente

Progetti base API

.NET FastEndpoints

Progetti base ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core e .NET 8.

C#.NET CLI
Chiave modello
dotnet-fastendpoints
Ambiente di esecuzione
dotnet
Repository
template-dotnet-fastendpoints
Percorso sorgente
.
git clone https://github.com/adiosdotdev/template-dotnet-fastendpoints.git
cd template-dotnet-fastendpoints
adios up
DistribuisciVisualizza sorgente

Progetti base API

.NET 8 Minimal API

Progetti base ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core e .NET 8.

C#.NET CLI
Chiave modello
dotnet
Ambiente di esecuzione
dotnet
Repository
template-dotnet-8
Percorso sorgente
.
git clone https://github.com/adiosdotdev/template-dotnet-8.git
cd template-dotnet-8
adios up
DistribuisciVisualizza sorgente

Progetti base API

.NET Blazor

Progetti base ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core e .NET 8.

C#.NET CLI
Chiave modello
dotnet-blazor
Ambiente di esecuzione
dotnet
Repository
template-dotnet-blazor
Percorso sorgente
.
git clone https://github.com/adiosdotdev/template-dotnet-blazor.git
cd template-dotnet-blazor
adios up
DistribuisciVisualizza sorgente

Progetti base API

.NET ABP Framework

Progetti base ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core e .NET 8.

C#.NET CLI
Chiave modello
dotnet-abp
Ambiente di esecuzione
dotnet
Repository
template-dotnet-abp
Percorso sorgente
.
git clone https://github.com/adiosdotdev/template-dotnet-abp.git
cd template-dotnet-abp
adios up
DistribuisciVisualizza sorgente

Progetti base API

.NET Orchard Core

Progetti base ASP.NET Core, Blazor, ABP, FastEndpoints, Orchard Core e .NET 8.

C#.NET CLI
Chiave modello
dotnet-orchard-core
Ambiente di esecuzione
dotnet
Repository
template-dotnet-orchard-core
Percorso sorgente
.
git clone https://github.com/adiosdotdev/template-dotnet-orchard-core.git
cd template-dotnet-orchard-core
adios up
DistribuisciVisualizza sorgente
Leggi la guida di distribuzione .NET

Prima della produzione

Verifica il carico di lavoro.Poi promuovilo.

Il primo rilascio più sicuro parte da una compilazione o configurazione del servizio riproducibile e da un'anteprima che mette alla prova le dipendenze effettivamente usate in produzione.

Sei pronto quando…

  • dotnet publish succeeds from a clean checkout.
  • L'assembly generato si avvia senza un profilo IDE.
  • L'app ascolta sull'URL e sulla porta di produzione configurati.
  • Le stringhe di connessione e le chiavi di firma usano segreti.

Verifica in anteprima quando…

  • La soluzione utilizza dipendenze native o specifiche della piattaforma.
  • Le migrazioni di Entity Framework modificano i dati di produzione.
  • Le connessioni Blazor o WebSocket richiedono test del rilascio.

Risposte alle tue domande

Cosa sapere prima di distribuire .NET.

Verifica i limiti dell'ambiente di esecuzione o del servizio, il percorso del modello, il comportamento in caso di errore e i controlli di produzione prima di creare il primo rilascio.

Adios può distribuire un progetto .NET esistente?

Sì. Esegui la CLI Adios dalla radice del progetto, mantieni il repository e i file delle dipendenze che usi già e aggiungi un file adios.yaml con compilazione di produzione, comando di avvio, porta e percorso di integrità.

Ho bisogno di Docker per distribuire .NET?

Non per un ambiente di esecuzione standard supportato. Usa i normali comandi di produzione del progetto in adios.yaml. Se la compilazione richiede pacchetti di sistema insoliti o librerie native, verifica le dipendenze in anteprima prima della promozione.

Quali modelli .NET sono disponibili?

Il catalogo include varianti ASP.NET Core, FastEndpoints, .NET 8 Minimal API, Blazor, ABP Framework e Orchard Core.

Posso distribuire una compilazione .NET dipendente dal framework?

Sì, se l'ambiente di esecuzione Adios scelto corrisponde al framework di destinazione. Mantieni espliciti l'output di pubblicazione e l'assembly da avviare e verifica in anteprima le librerie native necessarie.

Cosa succede se la compilazione o il controllo di integrità fallisce?

La versione candidata conserva l'output della compilazione e dell'esecuzione per l'ispezione. Deve superare i controlli di integrità prima di diventare la versione promossa che serve la route dell'applicazione.

Posso partire da un modello invece che da un repository esistente?

Sì. Questa pagina collega i modelli iniziali ufficiali Adios .NET più pertinenti. Esamina la variante esatta del codice sorgente, distribuiscila dalla console oppure clonala localmente ed esegui adios up.

Percorsi di distribuzione correlati

Collega il resto dello stack.

Sfoglia tutte le pagine di distribuzione

Distribuisci ASP.NET Core

Crea un artefatto di rilascio ASP.NET Core, fai ascoltare Kestrel sulla porta di produzione, verifica l'integrità e collega configurazione, log, domini e TLS.

Distribuisci PostgreSQL

Scegli una versione PostgreSQL, mantieni le credenziali del database fuori da Git, collega archiviazione persistente, connetti l'applicazione e verifica i dati dopo un riavvio.

Distribuisci Redis

Avvia Redis 7 per cache, sessioni, pub/sub o stato ad accesso rapido e verifica connettività, requisiti di persistenza, espulsione dei dati e comportamento in caso di errore delle dipendenze.

Distribuisci Workflow Adios

Distribuisci attività pianificate, processori di webhook, punti di approvazione, attività di manutenzione e automazioni operative da un manifesto di workflow versionato.

Il primo rilascio

Distribuisci .NET con il codice sorgente e le evidenze associati.

Parti dal repository o da un modello, verifica il contratto di distribuzione ed esamina la versione promossa in produzione.

Inizia con AdiosConfronta i piani