Artikelen the IT innovators

Disclaimer: Docker

Dit artikel gaat over het up-to-date blijven met .NET Core and .NET Framework wanneer je geen gebruik maakt van Docker. Gebruik je Docker, dan verwijs ik je graag naar dit uitstekende artikel: https://devblogs.microsoft.com/dotnet/staying-up-to-date-with-net-container-images/

 

Waarom up-to-date blijven?

Up-to-date blijven mbt .NET en .NET Core is om de volgende redenen belangrijk:

• Staying supported: Zodat je aanspraak kunt maken op Support van Microsoft.
• Staying secure: Zodat de door jou gebruikte .NET en .NET Core onderdelen gepatcht blijven met de laatste fixes en security updates.

 

Een stukje historie

Wanneer je, zoals ik, in het verleden applicaties hebt ontwikkeld op .NET Framework, was je amper bezig met kwetsbaarheden in .NET Framework. Die werden immmers automatisch gepatcht door Windows Update in de monthly .NET Framework Rollups of op Windows 10 in de Monthly Windows Update. Lees https://devblogs.microsoft.com/dotnet/introducing-the-net-framework-monthly-rollup/ voor meer informatie over de monthly .NET Framework Rollups. Voor meer informatie over de Monthly Windows Update op Windows 10 moet je hier zijn: https://docs.microsoft.com/en-us/windows/deployment/update/waas-overview#the-windows-servicing-model.

Een monthly .NET Framework Rollup installeerde geen nieuwe minor versions van het .NET Framework maar patchte wel de reeds geïnstalleerde versie met critical updates. Op deze manier kon de Operations afdeling zonder jouw directe tussenkomst als developer het onderliggende framework van de applicatie patchen. Daarnaast draaiden de webapplicaties onder IIS, die als onderdeel van Windows ook automatisch gepatched werden.

 

Het nieuwe .NET Core tijdperk ziet er echter anders uit:

• Windows update patcht niet automatisch de .NET Core en ASP.NET Core installatie.
• .NET Core bevat zijn eigen webserver, waardoor de "surface of attack" voor jouw applicatie groter is. De webserver is nu immers onderdeel van je applicatie en wordt daarnaast niet meer gepatcht als onderdeel van Windows update.

 

.NET Core

Staying supported

Wanneer je aanspraak wilt kunnen blijven maken op support van Microsoft, dan zal je applicatie gebruik moeten maken van een versie van het framework met het stempel LTS (Long-Term-Support) of Current. Deze stempels worden door Microsoft aan bepaalde versies gegeven om aan te geven hoe de versie gesupport zal worden.

Dit betekent dat je kun kiezen om:

• Op een LTS release te blijven voor een langere periode. (Minimaal 3 jaar vanaf het moment dat de release als LTS is benoemd). Voor deze specifieke versie zullen dan patches worden uitgebracht.
• Op de meest recente versie (Current) te draaien. Dit zorgt ervoor dat je moet upgraden zodra er een nieuwe versie uitkomt, wat kan betekenen dat je bijvoorbeeld een minor version of zelf een major version omhoog moet.

Meer informatie hierover kun je vinden op onderstaande link: https://dotnet.microsoft.com/platform/support/policy/dotnet-core

 

Staying secure

Secure blijven op .NET Core vereist:

• Installeren van patches voor jouw LTS version of
• Installeren van patches en mogelijk upgraden naar een hogere minor version wanneer je gebruik maakt van de Current version.

 

Up-to-date blijven met .NET Core

Voor .NET Core is er geen optie om met behulp van Windows Update automatische patches geïnstalleerd te krijgen. Je zal een nieuwe versie zelf moeten installeren.

Omdat je dit proces zelf moet faciliteren betekent dit dat:

• Je zelf moet zorgen dat je geïnformeerd bent over een patch/minor version.
• Je zelf moet zorgen voor het installeren van de patch/minor version.

 

Hoe word je geïnformeerd over een nieuwe patch/minor version?

De methode die ik hiervoor gebruik is om me in te schrijven op de ASP.NET core Announcements github repositories, die me per e-mail op de hoogte houden.

• https://github.com/aspnet/Announcements
• https://github.com/dotnet/announcements

Een andere optie die je kunt toepassen is door de release json automatisch te laten parsen en je eigen alerts te triggeren. https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json. Microsoft werkt aan een cross-platform library om deze file te gebruiken voor het bepalen van noodzakelijke updates. Bron: https://github.com/dotnet/core/issues/1781

 

Hoe kan ik (het framework onder) mijn applicatie patchen?

De manier waarop je je applicatie kunt patchen hangt af van de manier waarop je je applicatie gedeployd hebt.

Voor meer informatie bekijk je de volgende link: https://docs.microsoft.com/en-us/dotnet/core/deploying/

Uiteindelijk komt het erop neer of je het framework hebt opgenomen in je deployment (SCD) of dat een deployment methode (FDD or FDE) toepast die gebruikt maakt van het .NET Core shared framework (en mogelijk het ASP.NET shared framework) dat is geïntroduceerd in ASP.NET Core 2.1

 

FDD and FDE deployments

Een FDD of FDE deployment patchen

Als je deployt door gebruik te maken van "Framework-dependent deployments" (FDD) or "Framework-dependent executables" (FDE), maakt je applicatie gebruik van het shared framework, dat centraal op een computer is geïnstalleerd. Dit framework bevat zowel .NET Core als de ASP.NET Core runtime. Afhankelijk van de policy die je gespecificeerd hebt in de "runtimeconfig.json", kan jouw applicatie de nieuwe versie van het gepatchte Shared Framework gaan gebruiken, zodra deze is geïnstalleerd en de applicatie is herstart. Meer informatie hierover kun je vinden op: https://docs.microsoft.com/en-us/dotnet/core/versions/selection#framework-dependent-apps-roll-forward

Zorg er wel voor dat je de implicit package references gebruikt https://docs.microsoft.com/en-us/dotnet/core/tools/csproj#implicit-package-references. Let daarnaast op dat je geen direct package references legt door transitieve dependencies door een ProjectReference of third-party dependency. Meer informatie hierover vind je in de volgende blogpost: https://natemcmaster.com/blog/2018/08/29/netcore-primitives-2/#publish-trimming

Wanneer je meer invloed wil hebben op de runtime behaviour van jouw applicatie, bijvoorbeeld hoe de applicatie omgaat met geïnstalleerde patches en minors, lees dan meer hierover in de volgende blogpost: https://natemcmaster.com/blog/2019/01/09/netcore-primitives-3/#automatically-run-on-higher-major-or-minor-versions

FDD en FDE deployment zorgen er dus voor dat je eenvoudiger kunt patchen zonder dat je daarbij de applicatie hoeft te republishen. Natuurlijk bestaat er wel een kleine kans dat er issues ontstaan doordat je applicatie op een hogere versie van het framework gaat draaien dan waar jij het initieel op gepublished en getest hebt.

 

Upgrade naar .NET Core 2.1

Wanneer je je applicatie van een lagere versie hebt geupgrade naar .NET Core 2.1, bestaat de mogelijkheid dat je het framework niet goed "referenced" en daardoor geen goed gebruik maakt van het .NET shared framework. Om dit op te lossen kun je de volgende stappen volgen: https://docs.microsoft.com/en-us/aspnet/core/migration/20_21?view=aspnetcore-2.2

 

Draaien op een hogere minor version

Als je Current of LTS support plan volgt en aan het einde bent van de support periode, kan je genoodzaakt zijn om te upgraden. Wanneer je enkel een minor version omhoog hoeft, kan je dat doen zonder je applicatie te republishen door gebruik te maken van "Framework-dependent apps roll forward".

"Framework-dependent apps roll forward" zorgt ervoor dat je de applicatie op een hogere minor version zal draaien wanneer er geen beter geschikte minor version is geïnstalleerd. Meer informatie daarover vind je hier: https://docs.microsoft.com/en-us/dotnet/core/versions/selection#framework-dependent-apps-roll-forward

Wanneer je hiervan gebruik maakt moet je echter stil staan bij de volgende zaken:

• Een minor version bevat veel meer code wijzigingen dan een patch, waarmee de kans dat issues kunnen optreden voor je applicatie groter wordt.
• Wanneer er een geschiktere versie wordt geïnstalleerd, dan zal de applicatie effectief downgraden en daarna deze geschiktere applicatie gaan gebruiken. Ook al lijken de risico's klein, geef ik toch de voorkeur aan het republishen en opnieuw uitrollen van de applicatie.

Draaien op een hogere major version

Omdat een hogere major version waarschijnlijk breaking changes bevat, zal het altijd nodig zijn om de applicatie te upgraden, republishen en vervolgens uit te rollen.

 

SCD deployment

Als je gebruik maakt van een "Self-contained deployments", neem je het framework op in je applicatie tijdens het publishen. Meer informatie over het publishen van een SCD kun je hier vinden https://docs.microsoft.com/en-us/dotnet/core/deploying/runtime-patch-selection. Omdat het framework onderdeel is van jouw deployment, zal je een nieuwe deployment moeten maken om gebruik te maken van patches en updates. Deze manier van deployment introduceert allerlei nieuwe risico's, zoals onder andere hier beschreven: https://github.com/dotnet/core/issues/1541

 

ASP.NET Core op .NET Framework

Wanneer je ASP.NET Core op .NET Framework draait, liggen de zaken er iets anders voor.

 

Staying supported

Voor .NET Framework zul je moeten voldoen aan de product lifecycle policy van .NET Framework. Klik op de volgende link om een overzicht te bekijken met de belangrijkste datums mbt support voor de verschillende versies van .NET Framework. https://support.microsoft.com/en-us/lifecycle/search?sort=PN&alpha=Microsoft%20.NET%20Framework&Filter=FilterNO.

Daarnaast zul je voor ASP.NET Core moeten voldoen aan de support policy van .NET Core: https://dotnet.microsoft.com/platform/support/policy/dotnet-core.

 

Staying secure

Om "Secure" te blijven op .NET Framework kun je rekenen op de eerdergenoemde Windows Updates voor de patches. Ook kun je gebruik maken van hogere minor versions door het geïnstalleerde framework te upgraden.

Om "Secure" te blijven met ASP.NET Core zul je daarnaast:

• Zelf geïnformeerd moeten blijven over de benodige patches en updates
• Zelf de patches en updates moeten toepassen door de applicatie te republishen en opnieuw uit te rollen.

 

Tot slot

Na het lezen van deze post is het belangrijk je te realiseren dat ik in deze blog alleen .NET Framework, .NET Core en ASP.NET Core heb geadresseerd. Ongetwijfeld zul je veel meer afhankelijkheden hebben in je applicatie die ook gesupport en secure moeten blijven.

Stay up-to-date!

 

Sjoerd is Software Architect bij Blue Coded.
Meer informatie over bovenstaande onderwerpen? Neem contact op met Wouter Olde Weghuis om te horen hoe wij ook jouw applicaties up-to-date kunnen houden. Bel 079 - 330 1600

terug