.NET Conf

Współczesny programista .NET musi znać nie tylko pisanie kodu, ale też mieć dogłębną wiedzę z zakresu procesu wdrażania aplikacji – od koncepcji, przez budowanie, aż po produkcję. Kluczowe znaczenie mają: automatyzacja zadań, zarządzanie konfiguracją, konteneryzacja, implementacja pipeline’ów CI/CD, wybór platform wdrożeniowych oraz skuteczne monitorowanie i obserwowalność. To one minimalizują ryzyko wdrożeniowe i zapewniają wysoką jakość wytwarzanych rozwiązań.

Spis treści [odkryj]

Tworzenie projektu i konfiguracja początkowa

Początek realizacji aplikacji .NET to użycie polecenia dotnet new, uruchamiającego system szablonów i generującego strukturę projektu na podstawie wybranego szablonu. Zmiany w obsłudze szablonów pojawiły się od wersji .NET 7 SDK: dotychczasowe opcje –list, –search, –install, –uninstall przekształcono w podrzędne komendy.

Przykładowe rozpoczęcie pracy z ASP.NET Core prezentuje się następująco:

  • wykonanie polecenia dotnet new webapp -o aspnetcoreapp tworzy strukturę projektu webowego,
  • wszystkie kluczowe pliki i ustawienia znajdują się w wygenerowanym katalogu,
  • podstawowa aplikacja stanowi fundament dla rozbudowy funkcjonalności zgodnie z wymaganiami biznesowymi.

Już na tym etapie decydujemy o architekturze projektu i dopasowujemy środowisko do przyszłych wdrożeń.

Struktura projektu i konfiguracja środowiska

Podczas generowania aplikacji tworzony jest m.in. plik appsettings.json – domyślne miejsce do zarządzania konfiguracją.

  • system konfiguracji ASP.NET Core wykorzystuje hierarchię źródeł: argumenty CLI, zmienne środowiskowe, user secrets (w Development), appsettings.{Environment}.json,
  • mechanizm reloadOnChange: true gwarantuje, że modyfikacje w plikach konfiguracyjnych są wykrywane i stosowane dynamicznie,
  • łatwo zarządzamy osobną konfiguracją dla różnych środowisk (development, test, produkcja).

Hierarchiczny model ustawień umożliwia elastyczne zarządzanie bez zmian w kodzie źródłowym.

Zarządzanie szablonami i pakietami

.NET pozwala na tworzenie szablonów projektowych oraz ich dystrybucję przez NuGet. Podczas ich przygotowania należy:

  • zachować właściwą strukturę folderów z podziałem na content oraz indywidualne szablony,
  • wygenerować paczkę NuGet poleceniem dotnet pack i odpowiednią konfiguracją folderów,
  • wprowadzać wersjonowanie i przechowywać pakiety na repozytoriach NuGet.

Zarządzanie konfiguracją środowisk

Prawidłowa organizacja i bezpieczeństwo konfiguracji są kluczowe w całym cyklu życia aplikacji .NET.

Poniżej zestawiamy najważniejsze zasady zarządzania plikami i danymi konfiguracyjnymi:

  • w najprostszy sposób osiągać zamierzony efekt,
  • unikać powielania kluczy (redundancji),
  • stosować bezpieczne mechanizmy dla wrażliwych danych.

Typowa struktura plików konfiguracyjnych w firmowych projektach .NET wygląda następująco:

  • appsettings.json – ustawienia ogólne,
  • appsettings.Development.json – specyfika lokalnego developmentu,
  • appsettings.Test.json i appsettings.Production.json – indywidualna konfiguracja środowisk chmurowych.

Hierarchia ładowania konfiguracji

Hierarchia ładowania ustawień przebiega od ogólnego (appsettings.json) do środowiskowego (appsettings.{Environment}.json). Wartości z pliku środowiskowego nadpisują domyślne ustawienia, zapewniając elastyczność i bezpieczeństwo bez potrzeby manualnych zmian w kodzie.

Bezpieczeństwo konfiguracji

Wdrażając aplikację do chmury warto używać:

  • Azure Key Vault do zarządzania hasłami i kluczami na produkcji,
  • dotnet secrets w środowisku deweloperskim do bezpiecznego trzymania lokalnych danych.

Budowanie i publikowanie aplikacji

Budowanie i publikowanie w .NET to transformacja kodu programisty w finalny artefakt wdrożeniowy. Wynik dotnet build nie zawiera wszystkich wymaganych zależności do rzeczywistego wdrożenia. Dopiero dotnet publish generuje kompletną paczkę gotową do uruchomienia poza komputerem programisty.

Polecenie dotnet publish odpowiada za:

  • kompilację kodu źródłowego i generowanie assemblies,
  • rozwiązywanie i dołączanie zależności,
  • kopiowanie plików konfiguracyjnych oraz generowanie plików runtime.

Od .NET 8 domyślna konfiguracja polecenia dotnet publish to Release. To wymusza aktualizację pipeline’ów oraz standardów wdrożeniowych.

<TargetFramework> w pliku projektu określa wersję .NET używaną podczas publikacji, np. <TargetFramework>net9.0</TargetFramework> tworzy aplikację przeznaczoną dla .NET 9.

Tryby publikowania

Istnieją dwa główne tryby publikowania aplikacji .NET:

  • self-contained – cały runtime .NET i zależności zapakowane w aplikacji,
  • framework-dependent – aplikacja wymaga wcześniejszej instalacji środowiska .NET na maszynie docelowej.

Single-file deployment łączy wszystko w pojedynczy plik binarny. Tzw. „trimowanie” w .NET 6+ pozwala zmniejszyć rozmiar finalnego pakietu, jeśli aplikacja jest na to przygotowana.

Strategie konteneryzacji

Konteneryzacja .NET zapewnia przenośność, lepsze skalowanie i zarządzanie cyklem życia aplikacji.

Proces konteneryzacji zaczynamy od tworzenia pliku Dockerfile, w którym zamieszczamy instrukcje budowania obrazu np.:

  • FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS build – wybór obrazu SDK;
  • COPY . ./ i RUN dotnet publish -c Release -p:PublishDir=./output – budowanie projektu w kontenerze;
  • ENTRYPOINT ["dotnet", "aspnetcoreapp.dll"] – inicjowanie aplikacji w środowisku kontenerowym;
  • EXPOSE – deklarowanie dostępnych portów.

Budowanie wieloetapowe (multi-stage build) minimalizuje rozmiar finalnego obrazu, a oficjalne obrazy Microsoft gwarantują bezpieczeństwo i aktualność środowiska wdrożeniowego.

Ciągła integracja i ciągłe wdrażanie (CI/CD)

Pipeline CI/CD to podstawa profesjonalnego i powtarzalnego procesu wdrożeniowego w .NET.

Najczęściej wykorzystywane narzędzia to Azure DevOps Pipelines, GitHub Actions oraz DeployHQ:

  • Azure DevOps Pipelines – wsparcie dla projektów .NET Core, obsługa buildów, testów i publikacji artefaktów zadań;
  • DeployHQ – automatyzacja deployów przy każdym pushu w repo, generowanie kluczy SSH, komendy wdrożeniowe (npm, dotnet, migracje DB);
  • GitHub Actions – pełna automatyzacja buildów, testów, deploymentu do Amazon ECS oraz publikacja obrazów Docker na ECR.

Automatyzacja wdrażania z DeployHQ – przykładowy proces:

  • utworzenie projektu i wybór repozytorium do wdrożenia;
  • konfiguracja serwera – SSH, adresy, użytkownicy z uprawnieniami;
  • konfiguracja SSH na serwerze – przygotowanie katalogu ~/.ssh, konfiguracja chmod oraz dodanie klucza publicznego;
  • komendy wdrożeniowe – dotnet restore, dotnet publish -c Release, ewentualne migracje bazy oraz restart aplikacji.

GitHub Actions dla .NET 9 – główne etapy pipeline’u:

  • budowa obrazu Docker na GitHub,
  • publikacja na Amazon ECR,
  • tworzenie definicji zadania ECS,
  • aktualizacja i uruchomienie najnowszego obrazu Docker na Amazon ECS.

Platformy i strategie wdrażania

Wybór platformy wdrożeniowej determinuje szybkość, bezpieczeństwo i elastyczność prac produkcyjnych.

  • Azure App Service – szybkie deploymenty aplikacji webowych, wsparcie Visual Studio, PowerShell, GitHub Actions,
  • Azure Functions – serverless, automatyczne skalowanie, obsługa projektów .NET 8 w izolowanym procesie,
  • Amazon ECS – platforma do zarządzania kontenerami, idealna dla podejścia DevOps i architektury mikroserwisowej.

Przykładowy przebieg publikacji na Azure App Service:

  • publikacja aplikacji poleceniem dotnet publish --configuration Release,
  • utworzenie archiwum ZIP (Compress-Archive -Path * -DestinationPath deploy.zip -Force),
  • wysłanie archiwum do środowiska produkcyjnego (Publish-AzWebApp).

Strategie bezpiecznego wdrażania

Warto stosować następujące wytyczne:

  • spójny proces wdrażania i zarządzania zmianami produkcyjnymi – pełna kontrola nad zmianami,
  • progresywny rollout – etapowe wdrażanie ogranicza ryzyko,
  • modele zdrowia – każda faza rollout przechodzi checkpointy zdrowia,
  • szybkie wykrywanie i roll-back błędów – natychmiastowe zatrzymanie wdrożenia przy detekcji problemów.

Częste, niewielkie wdrożenia są bezpieczniejsze i łatwiejsze do zarządzania.

Monitorowanie i obserwowalność

Efektywna eksploatacja aplikacji .NET na produkcji wymaga zbudowania rozbudowanego systemu obserwowalności, obejmującego logowanie, monitoring oraz health checks.

Kluczowe technologie i narzędzia:

  • Serilog – logowanie strukturalne, bogaty ekosystem sink’ów, bezpośrednia integracja z Microsoft.Extensions.Logging;
  • Health checks – proaktywnie sprawdzają kondycję aplikacji (builder.Services.AddHealthChecks(), app.MapHealthChecks("/health"));
  • dotnet-monitor – monitorowanie i automatyczny zbiory diagnostyczne;
  • dotnet-counters – śledzenie wydajności, CPU i anomalii,
  • dotnet-trace – głębokie profilowanie kodu i badanie przyczyn problemów wydajnościowych.

To kompleksowe podejście umożliwia szybkie wykrywanie błędów i anomalii w produkcji oraz gromadzenie wartościowych metryk do dalszych analiz.