Jak převést a spravovat data z SQL Serveru do Azure Cosmos DB

Přenos dat z relační databáze, jako je SQL Server, do NoSQL databáze, jako je Azure Cosmos DB, vyžaduje nejen technické pochopení obou těchto systémů, ale i důkladné pochopení jejich rozdílů ve struktuře a přístupu k datům. Tento proces zahrnuje přizpůsobení modelů, přetváření datových struktur a správné nastavení aplikace pro komunikaci s novým systémem.

Začněme vytvořením modelů pro nové třídy, které budou odpovídat strukturovaným datům v SQL Serveru a současně splní požadavky na NoSQL strukturu.

V projektu Northwind.CosmosDb.SqlApi přidáme třídu CategoryCosmos.cs, která bude reprezentovat kategorii produktů v Cosmos DB:

csharp
Copy code
namespace Northwind.CosmosDb.Items;
public class CategoryCosmos {
    public int categoryId { get; set; }

    public string categoryName { get; set; } = null!;

    public string? description { get; set; }
}

Tato třída má základní vlastnosti odpovídající struktuře kategorie, včetně názvu kategorie a popisu. Při práci s Cosmos DB je důležité dodržovat konvence pro JSON pojmenování, což znamená, že vlastnosti budou psány v camelCase.

csharp
Copy code
namespace Northwind.CosmosDb.Items;
public class SupplierCosmos {
    public int supplierId { get; set; }

    public string companyName { get; set; } = null!;

    public string? contactName { get; set; }

    public string? contactTitle { get; set; }

    public string? address { get; set; }
    public string? city { get; set; }
    public string? region { get; set; }

    public string? postalCode { get; set; }

    public string? country { get; set; }
    public string? phone { get; set; }
    public string? fax { get; set; }

    public string? homePage { get; set; }

}

Nyní přicházíme k hlavní entitě, kterou budeme migrovat — produktům. Třída ProductCosmos.cs bude zahrnovat nejen samotný produkt, ale i propojené informace o jeho kategorii a dodavateli, protože Cosmos DB je určen k práci s dokumenty, které mohou obsahovat vnořené struktury. Tento přístup je přirozený pro Cosmos DB, protože ukládání souvisejících dat v rámci jednoho dokumentu výrazně zjednodušuje práci s těmito daty při jejich dotazování.

csharp
Copy code
namespace Northwind.CosmosDb.Items;
public class ProductCosmos {

    public string id { get; set; } = null!;

    public string productId { get; set; } = null!;

    public string productName { get; set; } = null!;

    public string? quantityPerUnit { get; set; }

    public decimal? unitPrice { get; set; }

    public short? unitsInStock { get; set; }

    public short? unitsOnOrder { get; set; }

    public short? reorderLevel { get; set; }

    public bool discontinued { get; set; }

    public CategoryCosmos? category { get; set; }
    public SupplierCosmos? supplier { get; set; }
}

Všimněte si, že u každé třídy je kladeno důraz na explicitní definici ID. To je důležité, protože v Cosmos DB je každý dokument identifikován unikátním ID, které umožňuje rychlé vyhledávání a správu dat.

Pro efektivní přenos dat z SQL Serveru do Cosmos DB musíme zajistit, že všechny produkty budou mít nejen svoji vlastní strukturu, ale také že budou propojeny s odpovídajícími kategoriemi a dodavateli. Tento krok provádíme pomocí metody CreateProductItems v souboru Program.Methods.cs, kde získáváme produkty z databáze Northwind SQL, včetně jejich kategorií a dodavatelů, a následně je přidáváme do kontejneru Cosmos DB:

csharp
Copy code
static async Task CreateProductItems() {
    double totalCharge = 0.0;
    try {
        using (CosmosClient client = new CosmosClient(endpointUri, primaryKey)) {
            Container container = client.GetContainer("Northwind", "Products");
            using (NorthwindContext db = new NorthwindContext()) {
                ProductCosmos[] products = db.Products
                    .Include(p => p.Category)
                    .Include(p => p.Supplier)
                    .Where(p => (p.Category != null) && (p.Supplier != null))
                    .Select(p => new ProductCosmos {
                        id = p.ProductId.ToString(),
                        productId = p.ProductId.ToString(),
                        productName = p.ProductName,
                        category = new CategoryCosmos {
                            categoryId = p.Category.CategoryId,
                            categoryName = p.Category.CategoryName,
                            description = p.Category.Description
                        },
                        supplier = new SupplierCosmos {
                            supplierId = p.Supplier.SupplierId,
                            companyName = p.Supplier.CompanyName,
                            contactName = p.Supplier.ContactName,
                            contactTitle = p.Supplier.ContactTitle,
                            address = p.Supplier.Address,
                            city = p.Supplier.City,
                            country = p.Supplier.Country,
                            postalCode = p.Supplier.PostalCode,
                            region = p.Supplier.Region,
                            phone = p.Supplier.Phone,
                            fax = p.Supplier.Fax,
                            homePage = p.Supplier.HomePage
                        },
                        unitPrice = p.UnitPrice,
                        unitsInStock = p.UnitsInStock,
                        reorderLevel = p.ReorderLevel,
                        unitsOnOrder = p.UnitsOnOrder,
                        discontinued = p.Discontinued,
                    })
                    .ToArray();
                foreach (ProductCosmos product in products) {
                    try {
                        ItemResponse productResponse = await container.ReadItemAsync(product.id, new PartitionKey(product.productId));
                        totalCharge += productResponse.RequestCharge;
                    } catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound) {
                        ItemResponse productResponse = await container.CreateItemAsync(product);
                        totalCharge += productResponse.RequestCharge;
                    }
                }
            }
        }
    } catch (Exception ex) {
        Console.WriteLine("Error: {0}", ex.Message);
    }
    Console.WriteLine("Total requests charge: {0:N2} RUs", totalCharge);
}

Tato metoda nejenže přenáší produkty, ale také loguje celkové náklady na požadavky (RUs — Request Units), které byly vynaloženy při operacích s Cosmos DB.

Jak správně implementovat a zabezpečit CORS a HTTP klienty ve webových aplikacích

V dnešní době, kdy se webové aplikace stále více spoléhají na komunikaci mezi různými službami a servery, je důležité správně nastavit a zabezpečit tyto interakce. V tomto kontextu je zvláště důležité pochopit, jak fungují HTTP klienti a jak správně implementovat CORS (Cross-Origin Resource Sharing) politiku pro zajištění bezpečné komunikace mezi aplikacemi na různých serverech.

Začněme tím, jak implementovat HTTP klienta a CORS politiku ve webové aplikaci, která se používá k načítání dat z externího API pomocí .NET.

V souboru HomeController.cs je vytvořena asynchronní metoda akce Products, která umožňuje vyhledávat produkty podle zadaného parametru name. Tento parametr může být volitelný a je součástí vlastní MVC trasy. Pomocí HTTP klienta, který je vytvořen prostřednictvím IHttpClientFactory, se odešle GET požadavek na externí webovou službu, která vrátí seznam produktů odpovídajících zadáním.

csharp
Copy code
[Route("home/products/{name?}")]

public async Task Products(string? name)
{
    HttpClient client = clientFactory.CreateClient(name: "Northwind.WebApi.Service");
    HttpRequestMessage request = new(HttpMethod.Get, requestUri: $"api/products/{name}");
    HttpResponseMessage response = await client.SendAsync(request);
    IEnumerable<Product>? model = await response.Content.ReadFromJsonAsync<IEnumerable<Product>>();
    ViewData["baseaddress"] = client.BaseAddress;
    return View(model);
}

Jakmile server zpracuje tento požadavek, vrátí seznam produktů odpovídajících zadanému názvu. V tomto případě metoda Products vyhledá produkty, jejichž název obsahuje část textu, který uživatel zadá do textového pole na stránce.

Dále je nutné vytvořit odpovídající pohled v souboru Products.cshtml, který vygeneruje tabulku s produkty, jež odpovídají zadanému názvu.

html
Copy code
@using Packt.Shared

@model IEnumerable<Product>
@{ ViewData["Title"] = "Products using .NET"; }
<h2>@ViewData["Title"]</h2>
@if (Model is not null)
{
    <table>
        <tr><th>Product Name</th></tr>
        @foreach (var p in Model)
        {

            <tr><td>@p.ProductName</td></tr>

        }
    </table>
}

Takto získané produkty se následně zobrazí v tabulce na stránce, kde uživatel může vidět seznam produktů, které odpovídají jeho hledanému výrazu.

Pokud bychom se pokusili odeslat požadavek na server, který má jinou doménu, než naše aplikace, narazíme na problém s politiku stejného původu (Same-Origin Policy), která brání přístupu k datům z jiných domén. Tento problém lze obejít použitím CORS (Cross-Origin Resource Sharing), což je bezpečnostní mechanismus, který umožňuje serverům určit, které domény mohou přistupovat k jejich prostředkům.

Jak správně nastavit CORS

csharp
Copy code
string northwindMvc = "Northwind.Mvc.Policy";
builder.Services.AddCors(options =>
{
    options.AddPolicy(name: northwindMvc,
        policy =>
        {
            policy.WithOrigins("https://localhost:5092");
        });
});

Tato konfigurace umožňuje přístup k API pouze z domény https://localhost:5092. Pokud by požadavky přicházely z jiné domény, server by je odmítl.

Po nastavení politiky CORS je třeba aplikovat tuto politiku v middleware pomocí metody UseCors. To se provádí následujícím způsobem:

csharp
Copy code
app.UseCors(policyName: northwindMvc);

Jakmile je CORS správně nastaven, můžete začít odesílat požadavky mezi různými doménami bez problémů s bezpečnostními restrikcemi prohlížeče.

Další možnosti konfigurace CORS

Pokud potřebujete větší kontrolu nad tím, jaké požadavky jsou povoleny, můžete přizpůsobit politiku CORS podle vašich potřeb. Můžete specifikovat povolené metody (např. GET, POST, DELETE), povolené hlavičky (např. Content-Type, Authorization), nebo dokonce vystavovat specifické hlavičky v odpovědích.

Například, pokud chcete povolit jakýkoliv origin, můžete použít wildcard (*):

csharp
Copy code
policy.WithOrigins("*");

Pokud chcete umožnit specifické metody, můžete přidat metody, které budou povoleny:

csharp
Copy code
policy.WithMethods("GET", "POST", "DELETE");

Tato flexibilita vám umožní přizpůsobit CORS politiku konkrétním potřebám vaší aplikace.

Význam bezpečnosti a ochrany proti útokům

Je nezbytné zabezpečit vaše aplikace proti těmto hrozbám správnou konfigurací CORS a také implementací dalších bezpečnostních opatření, jako je například ověřování a autorizace uživatelů před tím, než umožníte přístup k citlivým datům.

Pokud je cílem vaší aplikace přístup k datům z různých zdrojů a serverů, vždy pečlivě zvažte, které domény mají povolený přístup a jaké metody a hlavičky budou povoleny. CORS je skvélé řešení pro tento problém, ale musí být implementováno s rozvahou, aby nedošlo k otevření nebezpečných vstupů pro neautorizované osoby.