Jak skonfigurować bezpieczne API REST z użyciem JWT i ról użytkowników w ASP.NET Core

W tworzeniu aplikacji webowych, które obsługują autoryzację i autentykację użytkowników, jednym z kluczowych aspektów jest implementacja bezpiecznego API REST. W tym kontekście jednym z najczęściej używanych podejść jest wykorzystanie JSON Web Tokens (JWT) do zapewnienia bezpieczeństwa komunikacji między klientem a serwerem. Poniżej przedstawiamy, jak skonfigurować API REST z wykorzystaniem JWT w ASP.NET Core, uwzględniając również zarządzanie rolami użytkowników.

Pierwszym krokiem jest dodanie odpowiednich usług do aplikacji. W pliku Program.cs musimy skonfigurować OpenAPI i dodać obsługę JWT. W tym celu wykorzystujemy metodę AddOpenApi oraz konfigurujemy dokumentację API, w tym ustawienia bezpieczeństwa.

csharp
Copy code
builder.Services.AddOpenApi(options => {

    options.AddDocumentTransformer((document, context, cancellationToken) => {
        document.Info.Title = "Secure REST API";
        document.Info.Version = "v1";
        document.Info.Description = "A secure REST API with JWT authentication";
        // Dodanie schematu bezpieczeństwa JWT
        document.Components ??= new OpenApiComponents();
        document.Components.SecuritySchemes["Bearer"] = new OpenApiSecurityScheme {
            Type = SecuritySchemeType.Http,
            Scheme = "bearer",
            BearerFormat = "JWT",
            Description = "Enter JWT Bearer token"
        };
        return Task.CompletedTask;
    });
});

Następnie, aby umożliwić korzystanie z interfejsu użytkownika do testowania API (takiego jak Scalar UI), konfigurujemy odpowiednią usługę przed wywołaniem builder.Build(). Po zbudowaniu aplikacji, aktywujemy UI oraz mechanizmy autentykacji i autoryzacji.

csharp
Copy code
var app = builder.Build();
if (app.Environment.IsDevelopment()) {
    app.MapOpenApi();
    app.MapScalarApiReference(options => {
        options.Title = "Secure REST API";
        options.Theme = ScalarTheme.Purple;
        options.ShowSidebar = true;
        options.DefaultHttpClient = new ScalarClient(HttpTarget.CSharp);
    });
}
// Aktywacja HTTPS, autentykacji i autoryzacji
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();

Kolejnym krokiem jest skonfigurowanie bazy danych oraz migracji. W pliku appsettings.json musimy zdefiniować ciąg połączenia oraz klucz tajny dla tokenów JWT. Ponadto, warto pamiętać o używaniu silnego, losowego klucza dla JWT (najlepiej 32-znakowego).

json
Copy code
{

    "ConnectionStrings": {
        "MyDB": "server=localhost; database=Training2DB; uid=tester; pwd=pass123; Tr"
    },
    "AppSettings": {
        "Secret": "aaaaabbbbbcccccddddd11234df4444sd"
    }
}

Po ustawieniu ciągu połączenia i tajnego klucza dla JWT, przystępujemy do tworzenia migracji bazy danych i jej aktualizacji za pomocą komend Entity Framework Core:

bash
Copy code
dotnet ef migrations add InitialCreate
dotnet ef database update

Warto pamiętać, że w przypadku błędów związanych z InvariantGlobalization, można wyłączyć tę opcję w pliku projektu (.csproj).

Tworzenie ról użytkowników

W dalszym etapie musimy skonfigurować role, które będą przypisane użytkownikom. Tworzymy dwie role: „Admin” i „Manager”. Aby dodać te role do bazy danych, możemy wykorzystać API, które automatycznie utworzy odpowiednie wpisy w tabeli ról.

csharp
Copy code
app.MapGet("/setuproles", async (AppDbContext dbContext) => {

    var roles = dbContext.Roles.ToList();
    if(roles.Count <= 0) {
        dbContext.Roles.Add(new Role { Name = "Admin" });
        dbContext.Roles.Add(new Role { Name = "Manager" });
        await dbContext.SaveChangesAsync();
    }
    return Results.Ok(new { Message = "Roles were created" });
});

Dzięki temu upewniamy się, że w bazie danych znajdują się wymagane role, a aplikacja może je przypisać użytkownikom.

Endpointy rejestracji i logowania

Po skonfigurowaniu ról, kolejnym krokiem jest utworzenie endpointów rejestracji i logowania. Endpoint rejestracji umożliwia tworzenie nowych użytkowników z haszowanymi hasłami. Na potrzeby logowania, aplikacja autentykuje użytkowników na podstawie danych w bazie, a w przypadku poprawnej autentykacji generuje token JWT.

csharp
Copy code
app.MapPost("/register", async (AppDbContext dbContext, ApiUser usr) => {

    var user = new ApiUser {
        Username = usr.Username,
        Password = BC.HashPassword(usr.Password),
        Email = usr.Email,
        Name = usr.Name
    };
    dbContext.Users.Add(user);
    await dbContext.SaveChangesAsync();
    return Results.Ok();
});

Do logowania wykorzystujemy dane użytkownika przechowywane w bazie i, jeśli dane są poprawne, generujemy token JWT:

csharp
Copy code
app.MapPost("/login", (AppDbContext dbContext, IConfiguration configuration, LoginModel model) => {
    var usr = dbContext.Users.FirstOrDefault(o => o.Username == model.UserName);
    if (usr != null && BC.Verify(model.Password, usr.Password)) {
        var roles = dbContext.UserRoles
            .Where(userRole => userRole.User.Id == usr.Id)
            .Join(dbContext.Roles, userRole => userRole.RoleId, role => role.Id, (userRole, role) => role.Name)
            .ToList();
        var claims = new List<Claim> {
            new Claim(ClaimTypes.Name, usr.Username)
        };
        foreach (var role in roles) {
            claims.Add(new Claim(ClaimTypes.Role, role));
        }
        var key = configuration.GetValue<string>("AppSettings:Secret");
        var keyBytes = Encoding.ASCII.GetBytes(key);
        var symKey = new SymmetricSecurityKey(keyBytes);
        var creds = new SigningCredentials(symKey, SecurityAlgorithms.HmacSha256);
        var token = new JwtSecurityToken(
            claims: claims,
            expires: DateTime.Now.AddDays(2),
            signingCredentials: creds
        );

        return new UserToken { Token = new JwtSecurityTokenHandler().WriteToken(token), ExpiredAt = token.ValidTo.ToString() };

    }
    return new UserToken { Message = "Username or password is invalid" };
});

Przypisanie roli do użytkownika

W tym przypadku, zamiast tworzyć interfejs graficzny do zarządzania rolami, udostępniamy API do przypisania roli użytkownikowi. Endpoint /addrole/{username}/role/{rolename} pozwala przypisać użytkownikowi określoną rolę, jeśli użytkownik i rola istnieją w bazie danych.

csharp
Copy code
app.MapGet("/addrole/{username}/role/{rolename}", async (AppDbContext db, string username, string rolename) => {

    var role = db.Roles.FirstOrDefault(r => r.Name == rolename);
    var user = db.Users.FirstOrDefault(u => u.Username == username);
    if (role != null && user != null) {
        db.UserRoles.Add(new UserRole { User = user, Role = role });
        await db.SaveChangesAsync();
        return Results.Ok($"Role has been added to user {username}");
    }
    return Results.NotFound();
});

Zabezpieczanie zasobów

Aby zabezpieczyć dostęp do zasobów API, używamy atrybutu [Authorize] oraz przypisujemy role do różnych endpointów. Na przykład, endpoint /admin jest dostępny tylko dla użytkowników z rolą „Admin”:

csharp
Copy code
app.MapGet("/admin", [Authorize(Roles = "Admin")] () => {
    return Results.Ok(new { Message = "This content is only for admin" });
});

Podobnie zabezpieczamy inne endpointy, takie jak /manager, przydzielając odpowiednie role użytkownikom, którzy mogą je odwiedzać.

Jak wdrożyć aplikację ASP.NET Core 9.0 na serwerze Linux z Nginx jako odwrotnym proxy?

Pierwszym krokiem jest zainstalowanie .NET na systemie Ubuntu. Można to zrobić, korzystając z oficjalnej dokumentacji Microsoftu, która szczegółowo opisuje proces instalacji na systemach opartych na Linuksie. Aby zainstalować odpowiednią wersję .NET (w tym przypadku wersję 9.0), należy dodać klucz i repozytorium Microsoftu do systemu, a następnie przeprowadzić aktualizację pakietów. Kolejnym krokiem jest instalacja samego .NET SDK, co pozwala na tworzenie i uruchamianie aplikacji w .NET. Po zakończeniu instalacji, można sprawdzić wersję .NET za pomocą prostego polecenia dotnet --version.

Gdy .NET jest już zainstalowany, kolejnym etapem jest przygotowanie aplikacji. W tym przypadku zakładamy, że tworzymy minimalną aplikację API w ASP.NET Core. Można to zrobić, używając narzędzi CLI .NET. Projekt jest tworzony w nowym katalogu roboczym, a następnie otwieramy go w Visual Studio Code. Aplikacja powinna być odpowiednio skonfigurowana do pracy za odwrotnym proxy, co oznacza, że musimy wprowadzić odpowiednie zmiany w pliku Program.cs. Dodajemy middleware ForwardedHeaders w celu obsługi nagłówków przekazywanych przez Nginx.

Po zbudowaniu aplikacji należy ją opublikować. Korzystając z polecenia dotnet publish, tworzymy katalog zawierający wszystkie pliki potrzebne do uruchomienia aplikacji. Teraz możemy przejść do instalacji Nginx na naszym serwerze. Nginx będzie pełnił rolę odwrotnego proxy, przekazując zapytania HTTP do naszej aplikacji ASP.NET Core, która działa na porcie 5000. Aby uruchomić Nginx, należy zainstalować go, uruchomić i upewnić się, że będzie startował automatycznie przy każdym uruchomieniu systemu.

Po zainstalowaniu Nginx, należy skopiować opublikowane pliki aplikacji na serwer Linux. Zazwyczaj umieszcza się je w katalogu /var/www/dotnetapp. Ważne jest, aby odpowiednio ustawić uprawnienia do plików, zapewniając, że aplikacja ma dostęp do wszystkich niezbędnych zasobów. Należy również ustawić właściciela plików na odpowiedniego użytkownika i przyznać odpowiednie uprawnienia do katalogów.

Aby nasza aplikacja działała poprawnie jako usługa systemowa, musimy skonfigurować ją do uruchamiania jako demon. Tworzymy odpowiedni plik usługi systemd, który umożliwi automatyczne uruchamianie aplikacji po starcie systemu. W pliku tym należy podać lokalizację aplikacji oraz polecenie, które uruchamia naszą aplikację za pomocą dotnet. Po zapisaniu pliku należy uruchomić usługę i upewnić się, że jest ona włączona do startu systemu.

Testowanie wdrożenia polega na otwarciu przeglądarki internetowej i przejściu pod adres IP serwera lub jego nazwę domenową. Jeśli wszystko zostało skonfigurowane prawidłowo, powinna się wyświetlić aplikacja ASP.NET Core. Aby upewnić się, że aplikacja działa poprawnie, można sprawdzić jej funkcjonalność, otwierając odpowiednią stronę, np. /WeatherForecast.

Jeśli wszystko działa poprawnie, mamy do czynienia z w pełni działającym środowiskiem produkcyjnym. Należy jednak pamiętać o kilku istotnych kwestiach związanych z bezpieczeństwem i konserwacją. Regularna aktualizacja serwera oraz pakietów jest kluczowa, aby system był zabezpieczony przed nowymi zagrożeniami. Również warto wdrożyć odpowiednie środki ochrony, takie jak zapory ogniowe, certyfikaty SSL/TLS, oraz stosować najlepsze praktyki bezpieczeństwa. Ponadto, monitorowanie aplikacji i logów systemowych pozwala na szybsze wykrywanie ewentualnych problemów i reagowanie na nie.

Jak stworzyć prostą usługę kalkulatora i obsługę plików w ASP.NET Core 9.0?

Wraz z pojawieniem się wersji ASP.NET Core 9.0, wiele nowoczesnych podejść zostało udostępnionych w celu ułatwienia tworzenia aplikacji webowych. Jednym z takich udogodnień jest wbudowana obsługa OpenAPI, która nie tylko poprawia doświadczenie programisty, ale także zwiększa zgodność z obowiązującymi standardami branżowymi. Przykładem zastosowania tej technologii może być stworzenie usługi kalkulatora oraz obsługi przesyłania plików za pomocą Minimal API. Dwa scenariusze – budowa usługi kalkulatora i obsługa plików – pozwolą zapoznać się z istotnymi aspektami programowania w tym frameworku.

Kalkulator w Minimal API

Pierwszym ćwiczeniem, które przeprowadzimy, jest stworzenie prostej usługi webowej kalkulatora z wykorzystaniem ASP.NET Core 9. Minimal API pozwala na zdefiniowanie prostych punktów końcowych, które wykonują operacje matematyczne, takie jak dodawanie, odejmowanie, mnożenie i dzielenie. Dzięki tej metodzie tworzenie prostych aplikacji webowych staje się niezwykle szybkie i intuicyjne.

Kroki tworzenia aplikacji:

1. Tworzenie nowego projektu Minimal API:
   Na początek musisz stworzyć nowy projekt za pomocą polecenia dotnet new webapi, które utworzy szkielet aplikacji webowej w ASP.NET Core.

2. Definiowanie rekordu dla danych wejściowych:
   W pliku Program.cs należy zdefiniować rekord Numeric, który będzie przechowywał dane wejściowe (dwa liczby) oraz wynik operacji matematycznej. Rekord ten zapewnia prostą i efektywną obsługę danych.

   csharp
   Copy code
   record Numeric(double Number1, double Number2, double Result = 0);
   
   

3. Implementacja punktów końcowych:
   Kolejnym krokiem jest dodanie punktów końcowych dla każdej z operacji matematycznych. Dla każdej operacji (dodawanie, odejmowanie, mnożenie, dzielenie) będziesz korzystać z tego samego rekordu Numeric. Oto przykładowa implementacja dla dodawania:

   csharp
   Copy code
   var calculatorApi = app.MapGroup("/api/calculator");
   calculatorApi.MapPost("/add", (Numeric numbers) => {
       var result = numbers.Number1 + numbers.Number2;
       return Results.Ok(new Numeric(numbers.Number1, numbers.Number2, result));
   });
   

   Podobnie dodajesz punkty końcowe dla pozostałych operacji (odejmowanie, mnożenie, dzielenie), modyfikując tylko logikę obliczeń.

4. Testowanie aplikacji:
   

   Po zbudowaniu aplikacji przy pomocy polecenia dotnet run możesz przetestować ją za pomocą narzędzi takich jak Postman lub wbudowanego klienta REST. Testowanie polega na wysyłaniu żądań POST do odpowiednich punktów końcowych, a w ciele żądania przesyłasz dane liczbowe.

Obsługa przesyłania plików

Drugim ćwiczeniem w tym rozdziale jest implementacja funkcjonalności przesyłania i pobierania plików w ASP.NET Core 9. Minimal API może być również używane do obsługi plików w nowoczesnych aplikacjach webowych. Dzięki prostemu API możliwe jest łatwe dodawanie punktów końcowych, które pozwalają na przesyłanie i pobieranie plików z serwera.

Kroki tworzenia aplikacji:

1. Tworzenie nowego projektu:
   Podobnie jak w przypadku kalkulatora, na początek musisz stworzyć nowy projekt za pomocą dotnet new webapi. Następnie należy dodać folder uploads w katalogu wwwroot, który będzie służył jako miejsce przechowywania przesyłanych plików.

2. Wyłączenie walidacji antyforgery:
   Ponieważ do przesyłania plików wykorzystujemy dane typu multipart/form-data, musimy wyłączyć walidację tokenów antyforgery. Jest to szczególnie istotne przy przesyłaniu plików.

   csharp
   Copy code
   builder.Services.AddAntiforgery();
   
   

3. Dodanie punktu końcowego do przesyłania plików:
   Kolejnym krokiem jest zdefiniowanie punktu końcowego, który obsłuży przesyłanie plików. Oto przykładowa implementacja:

   csharp
   Copy code
   var fileApi = app.MapGroup("/api/file");
   fileApi.MapPost("/upload", async (IFormFile file, [FromForm] string description) => {
       var uploadsFolderPath = Path.Combine(app.Environment.WebRootPath, "uploads");
       Directory.CreateDirectory(uploadsFolderPath);
       var filePath = Path.Combine(uploadsFolderPath, file.FileName);
       using (var stream = new FileStream(filePath, FileMode.Create)) {
           await file.CopyToAsync(stream);
       }
   
       return Results.Ok(new { FilePath = $"/Uploads/{file.FileName}", Description = description });
   
   });
   

4. Dodanie punktu końcowego do pobierania plików:
   Kolejnym krokiem jest stworzenie punktu końcowego, który umożliwia pobieranie plików z serwera. Używamy do tego funkcji MapGet, wskazując ścieżkę do pliku w katalogu wwwroot/uploads.

   csharp
   Copy code
   fileApi.MapGet("/download/{fileName}", async (string fileName) => {
       var filePath = Path.Combine(app.Environment.WebRootPath, "uploads", fileName);
       if (!File.Exists(filePath)) {
           return Results.NotFound("File not found.");
       }
       var fileBytes = await File.ReadAllBytesAsync(filePath);
       return Results.File(fileBytes, "application/octet-stream", fileName);
   });
   

5. Testowanie aplikacji:
   Po zbudowaniu aplikacji, należy przetestować działanie przesyłania i pobierania plików, wysyłając odpowiednie żądania HTTP. Można to zrobić za pomocą narzędzi takich jak Postman lub wbudowanego klienta REST.

Dodatkowe uwagi

Należy pamiętać, że Minimal API to podejście, które upraszcza strukturę aplikacji, jednak w bardziej złożonych przypadkach, gdzie wymagane są bardziej zaawansowane mechanizmy bezpieczeństwa, walidacji czy logowania, warto rozważyć użycie pełnej wersji API w ASP.NET Core. W przypadku usług związanych z plikami, oprócz podstawowej obsługi przesyłania i pobierania, warto zwrócić uwagę na kwestie takie jak ograniczenie rozmiaru przesyłanych plików, walidacja ich typu oraz zapewnienie odpowiednich uprawnień do dostępu.

Jak skutecznie zarządzać bazą danych w projektach .NET Core: Podejście Code First i Database First

W przypadku pracy z istniejącą bazą danych, która została zaprojektowana przez oddzielny zespół lub pochodzi z innego źródła, najlepszym rozwiązaniem jest podejście Database First. EF Core (Entity Framework Core) umożliwia szybkie generowanie klas modelu oraz DbContext na podstawie już istniejącej struktury bazy danych. Narzędzie to pozwala na tzw. scaffolding, czyli automatyczne wygenerowanie kodu na podstawie tabel bazy danych. W tym procesie wystarczy użyć polecenia dotnet ef dbcontext scaffold, które pozwala na utworzenie odpowiednich klas. Z tego punktu widzenia praca z bazą danych staje się znacznie prostsza, ponieważ nie trzeba ręcznie tworzyć modeli ani migracji, co jest dużą oszczędnością czasu i wysiłku.

W przypadku rozwoju aplikacji, kiedy baza danych ulega zmianie, konieczne będzie ponowne wykonanie procesu scaffoldingu. Tego rodzaju zmiany mogą wiązać się z koniecznością dostosowania wygenerowanego kodu, aby odzwierciedlał on nową strukturę bazy danych. Należy pamiętać, że nawet drobne zmiany w bazie, takie jak dodanie kolumny do tabeli, mogą wymagać ręcznych poprawek w wygenerowanych klasach, aby zachować zgodność z danym schematem.

Zaletą podejścia Database First jest jego szybkość i efektywność, zwłaszcza w projektach, w których baza danych została zaprojektowana wcześniej i nie ma potrzeby tworzenia jej od podstaw. Jest to idealne rozwiązanie w sytuacjach, gdy zespoły odpowiedzialne za bazę danych i aplikację są rozdzielone. Dodatkowo, to podejście zmniejsza ryzyko błędów związanych z ręcznym pisaniem kodu dostępu do danych, ponieważ narzędzia EF Core automatycznie generują odpowiednie klasy i migracje.

Należy jednak pamiętać o kilku ważnych kwestiach, które mogą wpłynąć na jakość i wydajność aplikacji. Po pierwsze, wszelkie zmiany w schemacie bazy danych powinny być dokładnie przemyślane, aby nie prowadziły do problemów z synchronizacją kodu. Wszelkie modyfikacje w tabelach mogą wymagać ponownego generowania kodu i jego dostosowania. Z tego powodu ważne jest, aby dbać o wersjonowanie migracji w kontrolach wersji, szczególnie w podejściu Code First, które bazuje na migracjach do śledzenia zmian w bazie danych.

Kolejnym aspektem jest wydajność generowanych zapytań SQL. Chociaż EF Core oferuje różne mechanizmy optymalizacji, jak ładowanie leniwe (lazy loading) czy ładowanie chciwe (eager loading), warto zwrócić uwagę na to, jak zapytania są generowane przez framework. Źle zaprojektowane zapytania mogą prowadzić do problemów z wydajnością, zwłaszcza w przypadku pracy z dużymi zbiorami danych.

Kiedy już zdecydujemy się na odpowiednie podejście, EF Core oferuje szereg narzędzi, które pomagają w integracji z bazą danych. Narzędzia te są dostępne w postaci globalnych narzędzi .NET, które można zainstalować za pomocą polecenia dotnet tool install --global dotnet-ef. Dzięki nim możliwe jest nie tylko generowanie kodu, ale również zarządzanie migracjami czy aktualizowanie schematów bazy danych. Narzędzia te wspierają również testowanie i debugowanie aplikacji, co ułatwia ich integrację z bazą danych na każdym etapie rozwoju projektu.

Zalecenia związane z najlepszymi praktykami obejmują m.in. konieczność dbania o wersjonowanie migracji, odpowiednią organizację struktury bazy danych oraz regularne monitorowanie wydajności zapytań generowanych przez EF Core. Ważne jest także utrzymywanie synchronizacji między klasami modelu a schematem bazy danych, aby zmiany w jednym z tych elementów nie prowadziły do błędów lub niespójności w aplikacji.

Na zakończenie warto zaznaczyć, że Entity Framework Core oferuje wszechstronność, która sprawia, że jest to narzędzie odpowiednie zarówno dla aplikacji zaczynających od zera, jak i dla tych, które integrują się z już istniejącą bazą danych. Zrozumienie obu podejść oraz ich mocnych i słabych stron pomoże w optymalnym wykorzystaniu EF Core w różnych scenariuszach, zapewniając aplikacjom stabilność, wydajność i elastyczność w zarządzaniu danymi.

Jak używać migracji EF Core do tworzenia bazy danych i testowania API?

Aby rozpocząć pracę z Entity Framework Core w projekcie ASP.NET Core, który implementuje minimalne API, należy wykonać kilka kroków w celu skonfigurowania migracji, utworzenia bazy danych oraz zaimplementowania podstawowych operacji CRUD. Proces ten obejmuje wykorzystanie narzędzi EF Core do generowania schematów bazy danych oraz integracji z API. Poniżej przedstawiam szczegóły, jak przeprowadzić tę konfigurację oraz jak ją testować.

Pierwszym krokiem jest uruchomienie migracji EF Core w celu utworzenia bazy danych. Aby to zrobić, należy w terminalu wykonać polecenia:

bash
Copy code
dotnet ef migrations add InitialCreate

dotnet ef database update

Po ich wykonaniu, powinna zostać utworzona nowa baza danych, bazująca na połączeniu z bazą danych SQL Server, które zostało określone w pliku konfiguracyjnym. Jeśli podczas uruchamiania migracji napotkasz błędy związane z Invariant Globalization, możliwe jest, że będziesz musiał wyłączyć tę opcję w pliku projektu efcoredb.csproj, ustawiając InvariantGlobalization na false.

Jeżeli korzystasz z bazy danych w pamięci (In-Memory Database), nie musisz wykonywać dodatkowych konfiguracji. Możesz natomiast skoncentrować się na dodawaniu funkcjonalności, takich jak interfejs użytkownika API.

Jeśli chcesz wzbogacić dokumentację swojego API, możesz zainstalować paczkę Scalar UI dla OpenAPI, co zapewni bardziej przyjazny interfejs do interakcji z API. Aby zainstalować Scalar UI, należy wykonać następujące polecenie:

bash
Copy code
dotnet add package Scalar.AspNetCore

Następnie w pliku Program.cs trzeba skonfigurować aplikację, aby dodać obsługę Scalar UI:

csharp
Copy code
using Scalar.AspNetCore;
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
    app.MapScalarApiReference();
}

Po dodaniu Scalar UI możesz uruchomić aplikację za pomocą polecenia:

bash
Copy code
dotnet run

Warto również pamiętać, że możesz uruchomić aplikację z profilem HTTPS:

bash
Copy code
dotnet run --launch-profile https

Następnie, aby przetestować działanie API, stwórz plik EfCoreMinimalApi.http zawierający zapytania testowe do API:

http
Copy code
@efcoredb_HostAddress = http://localhost:5069

### Get all
GET {{efcoredb_HostAddress}}/products
Accept: application/json
### Get by id
GET {{efcoredb_HostAddress}}/products/1
Accept: application/json
### Create
POST {{efcoredb_HostAddress}}/products
Content-Type: application/json
{
  "name": "Product 1",
  "price": 100
}
### PUT
PUT {{efcoredb_HostAddress}}/products/1
Content-Type: application/json
{
  "name": "Product 41edit",
  "price": 100
}
### Delete by id
DELETE {{efcoredb_HostAddress}}/products/2
Accept: application/json

Pamiętaj, aby zmienić numer portu w zależności od ustawień aplikacji.

Kolejnym krokiem jest testowanie API. Możesz użyć rozszerzenia REST Client w Visual Studio Code, aby wysłać zapytania. Otwórz plik efcoredb.http, a następnie kliknij na link „Send Request” nad każdym zapytaniem, aby przetestować poszczególne punkty końcowe API. W przypadku dodawania nowych produktów możesz modyfikować treść żądania POST, a przy aktualizacji i usuwaniu produktów zmieniać odpowiednio żądania PUT i DELETE.

Alternatywnie, możesz również skorzystać z Scalar UI, otwierając przeglądarkę i przechodząc pod adres:

perl
Copy code
https:///scalar

Ostatecznie, jeśli chcesz w pełni zrozumieć, jak działa cała aplikacja, musisz nauczyć się, jak prawidłowo konfigurować połączenia z bazą danych i jak operować na danych za pomocą EF Core. Ponadto, ważne jest, byś znał sposób, w jaki API reaguje na różne zapytania HTTP (GET, POST, PUT, DELETE) i jak API obsługuje odpowiedzi. To pozwoli Ci na szybsze rozwiązywanie problemów oraz lepsze dostosowanie aplikacji do rzeczywistych potrzeb użytkowników.