NUKE: Automatizzare le build .NET

Nel mondo dello sviluppo software moderno, automatizzare le build non è più un lusso, ma una necessità. Che tu stia lavorando su un progetto personale o gestendo una pipeline CI/CD in un team enterprise, avere un sistema di build solido e leggibile è fondamentale.

E per chi lavora con l’ecosistema .NET, NUKE sta emergendo come uno dei migliori strumenti disponibili per automatizzare, organizzare e mantenere le build in modo professionale, pulito e scalabile.

Perché un sistema di build?

La “build” non è solo la compilazione del codice. In un progetto reale, la pipeline può includere:

Pulizia della soluzione
Ripristino dei pacchetti NuGet
Compilazione dei progetti
Esecuzione dei test
Analisi statica del codice
Pubblicazione su repository o artefatti
Deploy su ambienti (Dev, Test, Prod)

Automatizzare tutto questo significa ridurre errori, aumentare la produttività e facilitare la collaborazione tra sviluppatori e DevOps.

I limiti degli strumenti classici (MSBuild, Cake, Fake)

MSBuild

MSBuild è potente ma difficile da mantenere: è verboso, basato su XML e non è pensato per la leggibilità o la modularità. Anche una semplice logica condizionale può diventare complessa.

Cake

Cake (C# Make) migliora l’esperienza, scrivendo script in C#. Tuttavia, non offre la stessa integrazione forte con l’ambiente di sviluppo. Inoltre, molte funzionalità avanzate (come la debugabilità e l’autocompletamento IDE) sono limitate.

Fake

Fake (per F#) è un’altra opzione usata in alcuni ambienti, ma non è molto accessibile a chi lavora principalmente con C# o VB.NET.

Cos’è NUKE?

NUKE è un sistema di build open-source scritto interamente in C# e integrabile nativamente con .NET SDK. La sua forza risiede nella filosofia “build come codice di prima classe”, cioè: la build non è uno script separato, ma un vero e proprio progetto C# con tutti i vantaggi che ne derivano:

Debug completo da Visual Studio, Rider o VS Code
IntelliSense e refactoring
Integrazione diretta con NuGet, Git, Docker, CI/CD
Modularità e riusabilità

Caratteristiche principali

✅ Zero DSL: niente linguaggi strani o configurazioni XML/YAML: solo C#.
✅ Accesso a tutto l’ecosistema .NET: puoi usare qualsiasi libreria NuGet, tool CLI o SDK.
✅ Portabilità: cross-platform grazie a .NET.
✅ Configurazione semplificata: il setup iniziale richiede pochi minuti.
✅ Supporto per target, dipendenze e condizioni: in stile Makefile ma leggibile.

Perfetto! Continuo con la seconda parte del post, completando l’articolo fino a circa 2000 parole. Riprenderemo dal punto in cui abbiamo lasciato e andremo in profondità con un esempio pratico, CI/CD, e consigli utili.

Come funziona NUKE?

NUKE si basa su un concetto chiave: i “target”, ovvero metodi C# che rappresentano le fasi della build. Ogni target può dichiarare dipendenze da altri target, specificare condizioni di esecuzione, e contenere codice arbitrario.

Ogni build è un progetto .NET a tutti gli effetti, quindi puoi usare pacchetti NuGet, strumenti CLI, logging avanzato, ecc.

Setup passo-passo di un progetto NUKE

Ecco come creare un progetto NUKE da zero in 5 minuti.

1. Prerequisiti

.NET SDK installato
Git (opzionale ma consigliato)

2. Installazione

Apri un terminale nella root della tua soluzione .NET e lancia:

dotnet tool install Nuke.GlobalTool --global

Poi inizializza la build:

nuke :setup

Questo comando ti guiderà passo passo:

Dove creare i file di build
Quale IDE usare (Visual Studio, Rider, VS Code)
Nome del file .nuke
Target di default
Profilazione dei tool (dotnet, msbuild, ecc.)

Alla fine, avrai un file build.cs generato come base per la tua pipeline.

Esempio pratico di build con NUKE

Ecco un esempio base di build.cs:

[ShutdownDotNetAfterServerBuild]
class Build : NukeBuild
{
    public static int Main () => Execute<Build>(x => x.Compile);

    Target Clean => _ => _
        .Executes(() =>
        {
            FileSystemTasks.EnsureCleanDirectory(OutputDirectory);
        });

    Target Restore => _ => _
        .DependsOn(Clean)
        .Executes(() =>
        {
            DotNetTasks.DotNetRestore();
        });

    Target Compile => _ => _
        .DependsOn(Restore)
        .Executes(() =>
        {
            DotNetTasks.DotNetBuild(s => s
                .SetConfiguration(Configuration)
                .EnableNoRestore());
        });

    AbsolutePath OutputDirectory => RootDirectory / "output";

    Configuration Configuration => IsLocalBuild ? Configuration.Debug : Configuration.Release;
}

Con questo file, puoi lanciare:

nuke Compile

e NUKE eseguirà Clean → Restore → Compile, rispettando le dipendenze.

Integrazione con CI/CD

Una delle funzionalità più potenti di NUKE è l’integrazione con sistemi CI/CD come:

GitHub Actions
Azure DevOps
GitLab CI
TeamCity
Jenkins
Bitbucket Pipelines

Esempio: GitHub Actions

Genera la configurazione automaticamente:

nuke :ci

NUKE genererà i file YAML nella cartella .github/workflows.
Esempio generato:

name: CI
on:
  push:
    branches: [main]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '8.0.x'
    - run: dotnet tool restore
    - run: nuke Compile

Variabili e segreti

NUKE supporta facilmente l’accesso a variabili d’ambiente, segreti, chiavi API, e token di deploy, esponendoli tramite EnvironmentInfo o ParameterAttribute.

Best practice con NUKE

1. Organizza i target per responsabilità

Usa target separati per:

Build
Test
Pack
Publish
Deploy

Ogni target dovrebbe fare una cosa sola, bene.

2. Evita duplicazioni

Usa funzioni di supporto o classi helper per evitare codice duplicato tra i target.

3. Debug nativo

Avvia build.cs direttamente da Visual Studio o Rider: puoi impostare breakpoints, osservare variabili, usare l’autocompletamento.

4. Parametri dinamici

Usa [Parameter] per passare valori alla build:

[Parameter("Configuration to build - Default is 'Debug' (local) or 'Release' (server)")]
readonly Configuration Configuration = IsLocalBuild ? Configuration.Debug : Configuration.Release;

E lancialo così:

nuke Compile --configuration Release

5. Modularizza con componenti condivisi

Puoi creare librerie di step comuni da riutilizzare in più build, facilitando la manutenzione.

Estensioni e tool integrati

NUKE supporta nativamente tool come:

GitVersion per versionamento semantico
ReportGenerator per generare report da test coverage
Docker per build e push di immagini
Slack/Discord per notifiche
SonarQube per qualità del codice

E se non trovi quello che ti serve, puoi scrivere facilmente i tuoi step personalizzati in C#.

Testing e validazione della build

La build stessa è codice testabile. Puoi:

Scrivere unit test per gli step
Mockare tool esterni
Validare comportamenti in ambienti diversi (CI, locale, staging)

Confronto tra NUKE e Cake/Fake/MSBuild

Feature	NUKE	Cake	MSBuild
Linguaggio	C# puro	DSL su C#	XML
Debug IDE	✅	❌	❌
IntelliSense	✅	Limitato	❌
CI/CD integrato	✅	✅	❌
Testabilità	✅	Parziale	❌
Curva di apprendimento	Moderata	Bassa	Alta
Cross-platform	✅	✅	❌

Conclusione

NUKE è più di un semplice sostituto di MSBuild o Cake: è un’evoluzione del concetto stesso di sistema di build. Pensato per essere scalabile, manutenibile, leggibile e completamente integrato nel mondo .NET, NUKE offre tutto quello che serve per automatizzare i processi moderni.

Che tu stia lavorando in team enterprise o su progetti personali, NUKE ti permette di:

Risparmiare tempo
Evitare errori
Costruire pipeline CI/CD potenti e flessibili

Pubblicato

12 Giugno 2025

Aggiornato

11 Agosto 2025

Andrea Merlin in C#, Informatica, Programmazione | 12 Giugno 2025