Använd Doconut i distribuerad serverkonfiguration

När du behöver leverera PDF‑filer, Office‑filer, CAD‑ritningar eller bilder från ett kluster av ASP.NET Core‑noder, låter Doconut’s distributed mode varje nod läsa samma sidartefakter från en gemensam plats. Resultatet blir en horisontellt skalbar, säker visare som fungerar bakom en lastbalanserare utan sticky‑sessions.

Varför distribuerat läge är viktigt

• Skalbarhet – Varje nod kan publicera sidor till en UNC‑ eller molndelning; vilken annan nod som helst kan leverera dem omedelbart.
• Säkerhet – Artefakter lagras krypterade i den delade mappen; visaren validerar varje begäran mot ASP.NET‑sessionstoken.
• Ingen Office‑beroende – Konverterings‑pluginet körs på servern och konverterar Word, Excel, PowerPoint, CAD och bilder till PDF eller bilder utan att installera Microsoft Office.

Dessa egenskaper låter företags‑DMS, CRM‑ eller e‑learning‑portaler hålla dokumentbehandling inom .NET‑bakänden samtidigt som de skalas till dussintals containrar.

Delad lagring för distribuerat läge

I distribuerat läge förväntar sig Doconut att sidartefakter (PDF‑sidor, bild‑brickor osv.) skrivs till en lagringsplats som är åtkomlig för varje nod i farmen – en nätverksdelning, Azure Blob‑behållare, S3‑hink eller någon annan delad lagring som stöds av funktionen Progressive Cloud Publishing. Visaren söker automatiskt efter artefaktmappen som matchar per‑dokument‑säkerhetstoken, så ingen extra kod behövs förutom att säkerställa att alla noder har samma läs‑/skrivrättigheter till den valda lagringen.

Tips: Använd samma UNC‑sökväg (t.ex. \\fileserver\doconut) eller moln‑URL i varje instans konfiguration och håll mappbehörigheterna konsekventa. UsePerTokenSubfolders‑beteendet är aktiverat som standard och isolerar varje dokuments sidor.

Registrering av Doconut och sessions‑middleware

Doconut förlitar sig på ASP.NET Core‑sessionsstate för per‑dokument‑säkerhet. En distribuerad cache krävs endast när du använder ett minimal‑API‑projekt; MVC eller Razor Pages lägger redan till en.

builder.Services.AddDoconut(options =>
{
    options.LicensePath = "Doconut.Viewer.lic";
});

builder.Services.AddDistributedMemoryCache(); // session behöver en cache
builder.Services.AddSession();                 // Doconut validerar mot session

app.UseSession();               // Måste köras innan UseDoconut()
app.UseDoconutResources();      // Registrerar statiska viewer-tillgångar
app.Map("/doconut", branch => branch.UseDoconut());

Anpassade sökvägar (valfritt)

Om en annan rutt krockar med /doconut, ändra sökvägarna en gång och håll klienten BasePath i synk:

builder.Services.AddDoconut(options =>
{
    options.MiddlewarePath = "/docs-engine";
    options.ResourcesPath  = "/docs-assets";
});
app.UseDoconutResources();
app.Map("/docs-engine", branch => branch.UseDoconut());

Lägg aldrig till ett inledande snedstreck framför MiddlewarePath eller ResourcesPath; visaren lägger automatiskt till snedstrecket.

Så här gör du: Minimal‑API‑exempel

Nedan är en kompakt, produktionsklar konfiguration som kombinerar kravet på delad lagring, sessionshantering och Doconut‑registrering.

var builder = WebApplication.CreateBuilder(args);

// 1️⃣ Core Doconut registrering
builder.Services.AddDoconut(options =>
{
    options.LicensePath = Path.Combine(
        AppContext.BaseDirectory, "wwwroot", "Doconut.Viewer.lic");
    options.MiddlewarePath = "/doconut";
    options.ResourcesPath  = "/doconut-res";
});

// 2️⃣ Session och cache (krävs för säkerhet)
builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession();

var app = builder.Build();

app.UseRouting();
app.UseSession();
app.UseDoconutResources();                     // statisk viewer-paket
app.Map("/doconut", branch => branch.UseDoconut());

app.Run();

Distribuera denna binär till valfritt antal Docker‑containrar eller Windows‑tjänster bakom en lastbalanserare. Så länge varje instans kan nå den delade lagringsplatsen du konfigurerade för sidartefakter, kommer visaren att hämta sidor från vilken nod som helst, och uppladdningar/konverteringar överlever nodbyten.

Distribuera bakom en lastbalanserare

1. Exponera samma bas‑URL (t.ex. ` på varje nod.
2. Inaktivera sticky sessions – Doconut’s distribuerade läge tar bort behovet av sessionsaffinitet.
3. Säkerställ hälsokontroller som kontrollerar en grundläggande endpoint i din applikation (t.ex. /health) så att lastbalanseraren bara dirigerar trafik till levande noder.
4. Övervaka den delade mappen för tillväxt; standard‑TTL på 30 minuter håller lagringen begränsad, men du kan justera den efter efterlevnadsbehov.

Med dessa steg kan din dokumentintensiva .NET‑applikation leverera tusentals samtidiga visare, hålla varje sida krypterad i vila, och undvika overheaden av att installera Office på varje server.

Redo att prova? Skaffa ett gratis provperiod av Doconut, starta ett par containrar, peka dem mot en delad UNC‑sökväg, och se visaren skala utan en enda sticky‑session‑cookie.