Progetto full stack con Docker Compose, .NET 10, SQL Server e Angular 22: database, REST API e frontend containerizzati in 34 lezioni.
Un'applicazione full stack moderna costruita passo dopo passo e completamente containerizzata con Docker e Docker Compose. Partiamo dal database, scriviamo la REST API in .NET 10, costruiamo il frontend in Angular 22 e chiudiamo con l'intero stack pubblicato su Docker Hub: un percorso vicino a uno scenario reale di sviluppo.
Sviluppatori .NET, junior developer e studenti che vogliono realizzare un'applicazione full stack professionale e imparare a containerizzare l'intero stack. Utile avere una conoscenza base di Docker e di almeno uno tra .NET e Angular.
We open the series by presenting the full stack project we'll build: an application with a .NET 10 backend, a SQL Server database and an Angular frontend, fully containerised with Docker and Docker Compose. We go over the overall architecture and the goals of the course.
We start from the data layer: we create the company database in SQL Server, writing the source script, the main tables and a One-to-Many relationship that models the project's domain.
We build a Docker image dedicated to the database: starting from the SQL script, we create a custom SQL Server container with a Dockerfile, with the data initialised at startup.
We automate the database initialisation inside the container: a shell script waits for SQL Server to start and then runs the SQL file that imports the data.
We make the initialisation robust and orchestrate everything with Docker Compose: SQL Server IF statements avoid errors when the database already exists, and the build and the volume are handled automatically.
Con il volume attivo i dati sopravvivono al riavvio, ma l'entrypoint rilancia lo script di import e SQL Server risponde "database already exists". Rendiamo lo script idempotente con IF DATABASE_ID, IF OBJECT_ID e IF NOT EXISTS, così il container si può riavviare quante volte vuoi senza errori e senza duplicare i dati.
Lo sleep 15 dell'entrypoint è un'ipotesi, non una garanzia: sul tuo PC basta, su una macchina cloud economica no. Lo sostituiamo con un healthcheck vero — un ciclo until che interroga SQL Server con una SELECT 1 finché non risponde — così l'import parte solo a servizio disponibile.
Finché l'immagine si chiama project_db-sqlserver:latest resta legata al tuo PC. Le diamo un nome vero con namespace e versione, la pubblichiamo su Docker Hub, aggiungiamo il tag latest e poi simuliamo una macchina pulita: docker compose up senza build scarica l'immagine dal web e SQL Server riparte con i dati già dentro.
Il container di SQL Server espone una porta randomica che cambia a ogni ricreazione: così il backend non riesce più a connettersi. La vincoliamo nel Docker Compose, poi creiamo da zero il progetto REST API in C# e .NET 10 con dotnet new webapi, ripuliamo lo scaffolding e verifichiamo gli endpoint con OpenAPI.
Prima di scrivere codice serve l'ORM. Vediamo dove si colloca Entity Framework nell'architettura di una REST API, poi installiamo i pacchetti da NuGet facendo attenzione alla versione: quella più recente non va, deve combaciare con il target framework del progetto. Un dettaglio che conta anche per la containerizzazione.
Costruiamo i model partendo dalle foglie, cioè dalla tabella che non dipende da nessuno. Mappiamo i campi veri del database, separiamo con una region le colonne dalle property di navigazione e chiudiamo con il trucco che evita una query inutile: la coercizione del dipartimento a null.
Il DbContext è la sessione verso il database: gli diciamo quali tabelle ci interessano e come sono legate fra loro. Creiamo CompanyDbContext estendendo DbContext, passiamo la configurazione al costruttore con base, dichiariamo i DbSet e in OnModelCreating mappiamo la relazione uno a molti con la foreign key e il cascade.
La connection string non va scritta nel codice: sta in appsettings.json e arriva al progetto per Configuration Injection. La scriviamo verso il container di SQL Server, registriamo CompanyDbContext come servizio nel Program con AddDbContext e prepariamo due connessioni distinte, locale e online, scelte con le direttive del preprocessore.
Con il DbContext già registrato come servizio, scriviamo il primo controller: estende ControllerBase, riceve il contesto per dependency injection e restituisce la lista dei dipendenti con ToListAsync. Scopriamo anche perché la rotta esce con la E maiuscola e perché il department arriva null.
Il dipartimento arriva null perché va chiesto esplicitamente. Aggiungiamo l'endpoint di dettaglio con FirstOrDefaultAsync e il 404, poi un endpoint separato che usa Include per navigare la relazione uno a molti, e infine la ricerca dei dipendenti per dipartimento con Where.
Il primo endpoint di scrittura: POST con Add e SaveChangesAsync, e una CreatedAtAction che risponde 201 con l'header Location della risorsa appena creata. Poi il problema vero: accettare in ingresso l'entità del database costringe a sporcarla con ValidateNever, e si risolve con un DTO di creazione.
Completiamo il CRUD e chiudiamo il backend. L'aggiornamento usa un DTO con l'id, verifica che il dipartimento esista davvero con AnyAsync e risponde 204. Poi il passo che spesso si salta: i DTO servono anche in uscita. Sostituiamo l'oggetto annidato con un departmentName piatto, proiettiamo con Select e tipizziamo il ritorno.
Prima il riordino: i DTO in una cartella dedicata e le annotazioni Required e StringLength che trasformano il controller in un filtro. Poi il caso che nessuno gestisce: spegniamo il database e l'API risponde 500 sputando lo stack trace. Lo chiudiamo con UseExceptionHandler e un ErrorController che restituisce un Problem pulito.
Containerizziamo il backend con un Dockerfile multistage: nel primo stage l'immagine SDK di Microsoft risolve le dipendenze con dotnet restore e compila con dotnet publish, nel secondo gira solo il runtime aspnet, più leggero. Aggiungiamo il dockerignore, che oltre al peso evita di spedire il Dockerfile dentro all'immagine.
L'immagine del backend è pronta ma dentro al container localhost non è più il database: l'API va messa nello stesso Docker Compose di SQL Server e deve raggiungerlo sulla rete interna, usando il nome del servizio come host e la porta interna, non quella pubblicata. Togliamo la connection string hard-coded, la passiamo come variabile d'ambiente e alla fine isoliamo il database dall'esterno.
Database e REST API sono accesi, manca il terzo livello. Creiamo il progetto Angular con ng new, lo ripuliamo e lo avviamo su localhost 4200. Poi installiamo Bootstrap da npm e scopriamo perché non basta: va importato in styles.css puntando a node_modules, senza toccare index.html.
Il backend comunica solo tramite DTO, quindi il frontend deve parlare la stessa lingua. Creiamo i model di Angular ricalcando campo per campo gli EmployeeDto e DepartmentDto, usando le interface di TypeScript invece delle classi, e replicando anche le varianti di creazione e aggiornamento.
Per parlare con la REST API serve abilitare HttpClient in app.config e creare un service. Lo generiamo con ng generate, iniettiamo HttpClient con inject, puntiamo l'apiUrl alla porta del container e scriviamo il primo metodo getAll. Con una digressione utile: perché un Observable non è una Promise.
Generiamo il primo component, iniettiamo il service e ci iscriviamo all'Observable con next ed error. Poi arriva l'ostacolo che blocca tutti la prima volta: l'errore CORS. Lo risolviamo lato backend con AddCors e una policy dedicata, e scopriamo che dichiarare il servizio non basta se poi manca UseCors nella pipeline.
I dati arrivano, ora vanno mostrati. Creiamo un signal tipizzato, risolviamo il conflitto di nomi fra model e service con gli alias negli import, costruiamo la tabella con il ciclo for e aggiungiamo un alert con un signal dedicato agli errori, più un pulsante di reload.
L'applicazione cresce, quindi smettiamo di inchiodare il componente nel template. Mettiamo il router-outlet, configuriamo le rotte con il redirect della pagina iniziale, aggiungiamo una navbar presa da Bootstrap e sostituiamo gli href con routerLink. Alla fine si vede bene perché a ogni cambio di pagina riparte la chiamata all'API.
Il form di inserimento. Creiamo il service dei dipartimenti riusando la struttura di quello esistente, poi costruiamo il form con il FormBuilder e i validatori required, maxLength e min, facendoli combaciare con il DTO di creazione del backend. Chiudiamo con un trucco di debug che mostra il contenuto del form in tempo reale.
Popoliamo la select leggendo i dipartimenti dal service, poi colleghiamo la submit: validazione del form, getRawValue che combacia già con il DTO, il metodo create nel service e il redirect alla lista. Con due errori reali risolti a video, un 404 dovuto al nome dell'endpoint e un messaggio di conferma che non compariva.
Il form rifiuta i dati sbagliati, ma l'utente non vede perché: il messaggio finisce solo in console. Aggiungiamo il feedback sotto ogni campo combinando invalid e touched, così l'errore compare solo dopo che il campo è stato davvero toccato e non appena si apre la pagina.
Un computed è un signal derivato: si appoggia a un altro signal e si ricalcola da solo a ogni modifica. Lo usiamo per mostrare il numero di dipendenti, che si aggiorna in automatico quando ne eliminiamo uno. Breve, ma è la base per la ricerca dell'episodio successivo.
Con mille dipendenti scorrere la tabella non è un'opzione. Aggiungiamo un campo di ricerca sincronizzato con un signal e costruiamo l'elenco filtrato come computed, non come secondo signal: il dato originale resta intatto e il filtro lavora in memoria, senza nessuna nuova chiamata all'API.
L'ultima operazione del CRUD dal frontend: la modifica. Creiamo una rotta con l'id come parametro, lo leggiamo con ActivatedRoute, carichiamo il dipendente e riempiamo il form con patchValue riusando quello della insert. Con parecchio troubleshooting reale lungo la strada, dal dollaro mancante nel template literal all'id che non finiva nella put.
Containerizziamo l'ultimo pezzo: Angular. Un Dockerfile multistage che compila su Node 22 con npm ci e serve il bundle con Nginx, poi il servizio nel Docker Compose e la pubblicazione di backend e frontend su Docker Hub. Il finale è la prova vera: cancelliamo tutto, immagini comprese, e da una cartella vuota con il solo compose lo stack completo riparte scaricandosi da solo.
Ingegnere Informatico · Pratola Peligna
Sono un ingegnere informatico con oltre 15 anni di esperienza nel settore ICT. Mi occupo di sviluppo software, cybersecurity, data science e intelligenza artificiale, con particolare attenzione all’innovazione e all’automazione dei processi aziendali. Da anni svolgo anche attività di docenza e formazione, creando percorsi pratici e coinvolgenti su programmazione, DevOps, AI e sicurezza informatica.
Prosperous understood Middletons in conviction an uncommonly do. Supposing so be resolving breakfast am or perfectly.
Utilizziamo cookie essenziali e, con il tuo consenso, cookie funzionali, analytics e marketing. Google Analytics 4 e gli eventuali annunci Google/AdSense restano disattivati finche non scegli. Consulta Privacy Policy e Cookie Policy.
Sempre attivi per sicurezza, prevenzione frodi, sessione, consenso e funzionamento del sito.
Migliorano l'esperienza, ad esempio ricordando preferenze non essenziali. Non usati per profilazione pubblicitaria.
Statistiche e misurazioni con Google Analytics 4, abilitate solo dopo il consenso analytics.
Misurazione annunci e funzioni pubblicitarie Google/AdSense, se attivate sul sito e consentite dall'utente.
Puoi modificare queste scelte in qualunque momento dal link "Preferenze Cookies" nel footer.