Mantieni la compilazione ASP.NET Core che usi già
Usa dotnet publish per il progetto scelto e mantieni esplicita la directory di output. L'artefatto avviato in produzione è quello creato dalla compilazione verificata.
App e API · piani da $10/mese
Distribuisci ASP.NET Core.Pubblica ed esegui l'assembly scelto.
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.
Mantieni il repositoryEsamina compilazione e logDomini personalizzati e TLS
Distribuzione con Adios
Versione candidata
ASP.NET Core
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
ASP.NET Core.NET 8C#KestrelMinimal APIs
Il percorso di produzione
Un progetto ASP.NET Core 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.
Promuovi la versione che supera i controlli di integrità
Configura Kestrel tramite ASPNETCORE_URLS o le impostazioni dell'applicazione, esponi un endpoint di integrità ed esamina gli errori di avvio o delle dipendenze prima della promozione.
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.
- 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 - 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 - 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 progettoname: aspnet-api
build_cmd: dotnet publish -c Release -o out
start_cmd: dotnet out/MyApi.dll
runtime:
name: dotnet@8
port: 8080
health_path: /healthzSostituisci MyApi.dll con l'assembly generato e mantieni la porta coerente con la configurazione ASP.NET Core.
Punti di partenza pronti per la distribuzione
Avvia ASP.NET Core da un modello quando il repository non è pronto.
Confronta i modelli iniziali ASP.NET Core, Minimal API e FastEndpoints prima di scegliere la struttura del codice sorgente per il primo rilascio.
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 upProgetti 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 upProgetti 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 upPrima 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 emits the expected assembly.
- Kestrel ascolta l'indirizzo e la porta configurati.
- La route di integrità tiene conto delle dipendenze necessarie.
- Le stringhe di connessione e i valori di firma usano segreti.
Verifica in anteprima quando…
- L'app usa pacchetti nativi dell'ambiente di esecuzione.
- Le migrazioni di Entity Framework alterano i dati di produzione.
- Le connessioni SignalR o streaming necessitano di test di rilascio.
Risposte alle tue domande
Cosa sapere prima di distribuire ASP.NET Core.
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 ASP.NET Core 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 ASP.NET Core?
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.
Posso distribuire Minimal APIs e API basate su controller?
Sì. Entrambi vengono compilati in una normale applicazione .NET. Mantieni espliciti progetto da pubblicare, assembly di output, versione dell'ambiente di esecuzione, binding e route di integrità.
ASP.NET Core può usare PostgreSQL o Redis?
Sì. Distribuisci i servizi necessari, referenzia le credenziali tramite segreti e testa il ripristino delle connessioni e i controlli di integrità durante i riavvii delle dipendenze.
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 ASP.NET Core 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.
Distribuisci .NET
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 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 ASP.NET Core 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.