Jak vytvořit real-time aplikaci pomocí SignalR v ASP.NET Core

SignalR je knihovna pro ASP.NET, která usnadňuje přidávání real-time funkcí do aplikací. Umožňuje klientům komunikovat se servery a mezi sebou v reálném čase. Pomocí SignalR můžete například vytvářet chatovací aplikace, systém sledování úkolů nebo jiné aplikace, kde je potřeba okamžitě reagovat na změny dat. V této kapitole se podíváme na implementaci SignalR v ASP.NET Core aplikaci pro správu úkolů, která umožňuje klientům v reálném čase přidávat a označovat úkoly jako dokončené.

Začneme tím, že vytvoříme novou třídu TaskManagerHub, která bude dědit od základní třídy Hub z knihovny SignalR. Tato třída bude zodpovědná za komunikaci mezi serverem a klientem.

csharp
Copy code
public class TaskManagerHub : Hub

{
    public async Task CreateTask(TaskModel taskModel)
    {
        // ...
    }

    public async Task CompleteTask(TaskModel taskModel)

    {
        // ...
    }
}

Třída TaskManagerHub dědí od třídy Hub, což je základní třída pro všechny vlastní Hub třídy, které zprostředkovávají komunikaci mezi serverem a klientem. Dvě metody, CreateTask a CompleteTask, budou zpracovávat přijaté požadavky od klientů a zároveň mohou vyvolávat metody na klientech.

Pro práci s úkoly definujeme třídu TaskModel, která bude obsahovat základní informace o úkolu: identifikátor (Id), název (Name) a stav (IsCompleted), který určuje, zda je úkol dokončen.

csharp
Copy code
public class TaskModel

{
    public Guid Id { get; } = Guid.NewGuid();
    public string Name { get; set; }
    public bool IsCompleted { get; set; }
    public TaskModel()
    {
        IsCompleted = false;
    }

    public TaskModel(string name) : this()

    {
        Name = name;
    }
    public TaskModel(string name, bool isCompleted)
    {
        Name = name;
        IsCompleted = isCompleted;
    }
}

Když klient zavolá metodu CreateTask, server uloží úkol do paměti a následně odešle notifikaci všem připojeným klientům. Toho dosáhneme pomocí metody SendAsync:

csharp
Copy code
public async Task CreateTask(TaskModel taskModel)

{
    _taskRepository.Save(taskModel);
    await Clients.All.SendAsync(ClientConstants.NOTIFY_TASK_MANAGER, taskModel);
}

Tato metoda nejprve uloží úkol do úložiště (v našem případě do paměti) a poté informuje všechny připojené klienty o novém úkolu pomocí metody SendAsync. K identifikaci metody na straně klienta používáme konstantu ClientConstants.NOTIFY_TASK_MANAGER.

Po implementaci Huba je nutné nastavit server, aby mohl komunikovat prostřednictvím SignalR. V souboru Program.cs přidáme potřebnou konfiguraci:

csharp
Copy code
var builder = WebApplication.CreateBuilder(args);

// Přidáme SignalR služby
builder.Services.AddSignalR();
// Nastavení aplikace
var app = builder.Build();
app.MapRazorPages();
app.MapHub<TaskManagerHub>("/taskmanagerhub");
app.Run();

Důležité je, aby volání builder.Services.AddSignalR() bylo provedeno před vytvořením aplikace (před builder.Build()). Tímto způsobem je aplikace připravena na práci s SignalR.

Teď je čas připravit klientskou aplikaci. V souboru Pages/index.cshtml vytvoříme jednoduché HTML rozhraní, které bude obsahovat formulář pro přidání úkolu a seznamy pro zobrazení dokončených a nedokončených úkolů. V tomto případě budeme používat klasickou aplikaci Razor Pages, ale pro reálné aplikace je často vhodné použít moderní přístup SPA (Single Page Application) s frameworky jako Angular, React nebo Vue.js.

html
Copy code
@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}
<h2>SignalR Task Manager</h2>
<form id="createTaskForm">
    <input type="text" id="taskName" placeholder="Enter task name" required />

    <button type="submit">Add Task</button>

</form>
<h3>Uncompleted Tasks</h3>
<ul id="uncompletedTasks"></ul>
<h3>Completed Tasks</h3>

<ul id="completedTasks"></ul>

@section Scripts {
    <script src="https://cdn.jsdelivr.net/npm/@microsoft/[email protected]/dist/browser/signalr.min.js"></script>
    <script>
        const connection = new signalR.HubConnectionBuilder()
            .withUrl("/taskmanagerhub")
            .build();

        connection.on("ReceiveTask", function (task) {

            // Handle task update
        });
        connection.start().catch(err => console.error(err));
        document.getElementById("createTaskForm").addEventListener("submit", function (event) {
            event.preventDefault();
            const taskName = document.getElementById("taskName").value;
            connection.invoke("CreateTask", { Name: taskName }).catch(err => console.error(err));
        });
    </script>
}

Na straně klienta používáme JavaScript pro komunikaci s Hubem a pro zpracování úkolů. Po připojení k SignalR serveru klient zavolá metodu CreateTask, která pošle nový úkol na server.

Pokud se rozhodnete použít SPA, můžete místo Razor Pages použít JavaScript, TypeScript nebo jiný moderní framework. Tento přístup je užitečný pro vytváření bohatších uživatelských rozhraní a oddělení klientské logiky od serverové části.

Jak implementovat CORS a zabezpečit webové aplikace v ASP.NET Core 9

CORS (Cross-Origin Resource Sharing) je důležitým mechanismem, který umožňuje webovým stránkám načítat zdroje z jiných domén než z těch, na kterých byly původně načteny. Tento mechanismus se používá k určení, jaké domény mohou přistupovat k určitým prostředkům na serveru. ASP.NET Core 9 poskytuje silný rámec pro implementaci CORS v aplikacích, což vývojářům umožňuje definovat politiky pro správu přístupů k těmto prostředkům. Například, pomocí metody AllowAnyMethod() lze definovat, že jakýkoliv HTTP metod (GET, POST, PUT, DELETE a další) může být použit v rámci požadavku. Tento přístup je ideální v případech, kdy není potřeba omezovat specifické HTTP metody.

I když CORS není přímo mechanismem bezpečnosti, jeho správné použití přispívá k ochraně aplikace tím, že se omezí neautorizovaný přístup z jiných domén. V některých případech může být nutné explicitně definovat HTTP hlavičky a metody, které mohou být použity daným původem. Tato flexibilita dává vývojářům možnost nastavit různá pravidla pro různé typy aplikací, včetně těch, které běží jako SPA (Single Page Application) nebo jiné aplikace na klientovi.

Ochrana aplikace před běžnými zranitelnostmi

Bezpečnost aplikací je široce diskutovaným tématem, které zahrnuje nejen bezpečnost samotného kódu, ale také správu serverů, šifrování komunikace, správu identit a mnohé další aspekty. V ASP.NET Core 9 máme k dispozici nástroje a nejlepší praktiky, jak se chránit proti běžným zranitelnostem. Mezi nejčastější patří SQL injekce, Cross-Site Scripting (XSS) a Cross-Site Request Forgery (CSRF).

SQL Injekce

Cross-Site Scripting (XSS)

XSS útoky spočívají v injektování škodlivých skriptů do webových stránek. Tento útok je často zaměřen na webové aplikace, které umožňují uživatelům zadávat a odesílat data. Abychom se ochránili před XSS, musíme vždy správně kódovat nebo escapovat uživatelský vstup, než jej zobrazíme v prohlížeči. V ASP.NET Core 9 máme k dispozici vestavěné nástroje pro sanitaci výstupu, které nám pomáhají zamezit vykonání skriptů.

Příklad:

razor
Copy code
@{ var inputSimulator = "<script>alert('Injected Code');</script>"; }

@inputSimulator
// Výstup: <script>alert('Injected Code');</script>

Po správné kódování se tento kód stane pouze textovým řetězcem, který se nezpracuje jako JavaScript.

Cross-Site Request Forgery (CSRF)

CSRF útoky nastávají, když škodlivá stránka přiměje prohlížeč uživatele provést akce na jiném webu, na kterém je uživatel přihlášen. To může vést k neautorizovaným akcím, jako je změna nastavení nebo provedení plateb. ASP.NET Core poskytuje mechanismy ochrany proti CSRF pomocí anti-forgery tokenů, které se automaticky přidávají do formulářů a validují na serveru. Tyto tokeny zajišťují, že žádná škodlivá stránka nemůže zneužít autentifikaci uživatele.

Příklad implementace:

razor
Copy code
@Html.AntiForgeryToken()

A následně je potřeba přidat atribut ValidateAntiForgeryToken do akce, která zpracovává požadavek formuláře.

Doporučení pro zajištění bezpečnosti aplikací

Pro maximální ochranu je doporučeno používat také bezpečnostní hlavičky, jako je HTTP Strict Transport Security (HSTS), Content Security Policy (CSP) nebo X-Content-Type-Options, které přispívají k prevenci proti některým útokům.

Stejně tak je nezbytné věnovat pozornost správnému nastavení serveru a jeho konfiguraci. Tento proces zahrnuje správu firewallů, omezení přístupových práv, šifrování databází a používání bezpečných protokolů, jako je HTTPS.

V oblasti autentifikace je důležité nejen implementovat OAuth 2.0 nebo OpenID Connect (OIDC), ale také správně spravovat session, používat vícefaktorovou autentifikaci a monitorovat přihlašovací pokusy. Když je aplikace napadena, jedním z hlavních mechanismů pro analýzu a zlepšení bezpečnosti jsou logy, které poskytují cenné informace o chování aplikace a potenciálních útocích.

Jak využít technologii CNCF pro vývoj cloud-native aplikací

Abychom pochopili, jak můžeme CNCF využít ve svůj prospěch, podívejme se na scénář vývoje řešení založeného na ASP.NET Core 9, hostovaného na Microsoft Azure.

Scénář vývoje cloud-native aplikace

Představme si, že vyvíjíte webovou aplikaci pomocí ASP.NET Core 9 a aplikace je hostována na Azure. Chcete zajistit, že aplikace bude vyvíjena v souladu s cloud-native principy a bude využívat nejlepší dostupné nástroje pro nasazení, monitorování a správu. Jak CNCF může podpořit architektonické definice a vývoj aplikace v tomto scénáři?

Další klíčovou součástí je orchestrace kontejnerů. Pro tento účel si zvolíte Kubernetes, projekt, který také patří mezi absolventy CNCF, pro správu kontejnerů. Azure Kubernetes Service (AKS) poskytuje spravované prostředí Kubernetes v Azure, což umožňuje jednoduché nasazení, správu a škálování kontejnerizovaných aplikací. AKS využívá standardy definované CNCF pro Kubernetes, ale zároveň abstrahuje složitost vytváření clusteru a nabízí řadu dalších služeb pro snadnější správu.

Pro zajištění automatizace vývoje si vyberete nástroje pro CI/CD, jako je Jenkins nebo GitHub Actions. Tyto nástroje zajišťují, že změny v kódu jsou neustále integrovány a nasazovány, čímž se urychluje vývojový cyklus a zvyšuje se konzistence nasazení.

Monitoring a logování jsou nezbytnou součástí pro zajištění výkonu aplikace. CNCF nabízí projekty jako Prometheus pro sběr metrik a Grafana pro jejich vizualizaci. Tyto nástroje poskytují přehled o chování aplikace a pomáhají rychle diagnostikovat a řešit problémy. Další nástroj, jako je OpenTelemetry, poskytuje nezávislého agenta pro sběr metrik, čímž se snižuje závislost na proprietárních knihovnách.

Cloud-native principy a jak je aplikovat

CNCF poskytuje širokou paletu nástrojů pro vývoj, nasazení a správu cloud-native aplikací. Když se zaměříme na vývoj aplikace v ASP.NET Core 9, můžeme zajistit, že aplikace bude škálovatelná, odolná a snadno udržovatelná. Containerizace s Dockerem, orchestrace s Kubernetes, monitoring s Prometheem a Grafanou a automatizované CI/CD procesy pomocí Jenkins nebo GitHub Actions jsou jen některé z možností, jak využít CNCF nástroje k zefektivnění vývojového workflow.

Pro vývojáře je důležité pravidelně navštěvovat webové stránky CNCF a sledovat novinky a změny v cloudových modelech, stejně jako analyzovat nástroje v technologické krajinné mapě pro potřeby jejich řešení. Tato zdroje pomohou vytvářet stále silnější řešení, která se přizpůsobí různým potřebám organizace a trhu.

Vedle použití CNCF projektů existují také další důležité principy, které vedou vývoj cloud-native aplikací. Mezi ně patří metodologie dvanácti faktorů (12-factor app), která poskytuje soubor nejlepších praktik pro vývoj moderních, škálovatelných a udržitelných aplikací v cloudu. Tato metodologie, která byla vytvořena vývojáři Heroku, zajišťuje, že aplikace bude snadno spravovatelná a přenositelná mezi různými prostředími.

Metodologie dvanácti faktorů

Metodologie dvanácti faktorů zahrnuje dvanáct základních principů, které by měly být dodržovány při vývoji aplikací:

1. Code base: Používejte verzovanou kódovou základnu.

2. Dependencies: Explicitně deklarujte a izolujte závislosti.

3. Config: Ukládejte konfiguraci do prostředí.

4. Backing services: Zacházejte s podpůrnými službami jako s připojenými prostředky.

5. Build, release, run: Oddělujte fáze sestavení, vydání a spuštění.

6. Processes: Aplikace by měla být spuštěna jako stateless procesy.

7. Port binding: Služby exportujte pomocí port bindingu.

8. Concurrency: Rozšiřujte aplikaci pomocí modelu procesů.

9. Disposability: Minimalizujte dobu spuštění a plynulý shutdown.

10. Dev/prod parity: Udržujte co největší podobnost mezi vývojovým, testovacím a produkčním prostředím.

11. Logs: Zacházejte s logy jako s událostmi.

12. Administrative processes: Provádějte administrativní úkoly jako jednorázové procesy.