Att begränsa systemresurserna som används av en applikation kan göras genom en mängd olika metoder, beroende på operativsystemet och den specifika resursen du vill kontrollera. Här är några vanliga tillvägagångssätt:
1. Operativsystemnivågränser:
* CPU -gränser:
* Linux (CGROUPS): Kontrollgrupper (CGROUPS) låter dig begränsa CPU -tid, minne och I/O -resurser tillgängliga för en process eller en grupp processer. Du kan använda verktyg som `CGCreate` och` CGExec` för att skapa och hantera CGROUPS.
* Linux (renice): Kommandot "Renice" låter dig justera schemaläggningsprioriteten för en process. Lägre prioritetsprocesser kommer att få mindre CPU -tid.
* Windows (Process Priority): Du kan ändra prioriteringen av en process genom Task Manager, vilket ger den en lägre prioritet (t.ex. "under normal") för att minska dess CPU -användning. Mer granulär kontroll kan kräva användning av Windows API.
* Windows (resursguvernör): Denna funktion möjliggör centraliserad resurshantering för SQL Server och andra arbetsbelastningar. Det är inte ett allmänt verktyg för alla applikationer men kan vara mycket effektivt i specifika databasscenarier.
* Minnesgränser:
* Linux (CGROUPS): Som nämnts ovan kan cgroups begränsa mängden RAM som en process kan använda. Om det försöker överskrida gränsen kommer operativsystemet vanligtvis att döda eller strypa processen.
* Windows (jobbobjekt): Jobbobjekt ger ett sätt att hantera en grupp processer och sätta gränser för deras minnesanvändning. Överskridande gränsen kan leda till procesavslutning.
* docker (minnesgränser): När du kör applikationer i Docker-containrar kan du ange minnesgränser med flaggan "-Memory".
* I/O -gränser:
* Linux (CGROUPS): CGROUPS kan också begränsa I/O -operationer (läs och skriv) som utförs genom en process.
* Windows (IO Priority): I likhet med CPU -prioritet låter Windows dig ställa in I/O -prioriterade klasser för processer.
* Öppna filer gränser:
* Linux (ulimit): Kommandot "ulimit" låter dig ställa in gränser för antalet öppna filer som en process kan ha.
* Windows (procesgränser): Du kan styra öppna filgränser genom registret eller grupppolicyn.
2. Ansökningsnivågränser:
* Programmeringsspråkfunktioner: Många programmeringsspråk tillhandahåller mekanismer för att hantera resurser inom själva applikationen. Till exempel kan du begränsa storleken på buffertar, antalet trådar eller mängden minne som tilldelas dynamiskt. Detta görs ofta med specifika bibliotek eller API:er.
* Konfigurationsfiler: Många applikationer har konfigurationsfiler där du kan ange gränser för olika aspekter av deras beteende, som antalet tillåtna anslutningar, storleken på cachade data etc.
* Intern resurshantering: Väl utformade applikationer innehåller ofta sin egen interna resurshantering för att förhindra utmattning av resurser. Till exempel kan en webbserver begränsa antalet samtidiga förfrågningar den handtag.
3. Virtualisering:
* virtuella maskiner (VM): Att köra applikationer i virtuella maskiner ger ett lager av isolering och gör att du kan ställa in resursgränser (CPU, minne, diskutrymme) för hela VM. Detta är en kraftfull metod för att innehålla resursanvändning.
* containrar (Docker, Kubernetes): Behållare ger en lätt form av virtualisering. I likhet med VMS tillåter de dig att ange resursgränser för applikationen som körs i behållaren.
Att välja rätt metod:
Den bästa metoden beror på dina behov och sammanhang. För finkornig kontroll över enskilda processer är verktyg på operativsystemnivå som CGROUPS (LINUX) eller jobbobjekt (Windows) kraftfulla. För bredare kontroll över grupper av processer eller tillämpningar föredras ofta virtualisering eller containerisering. Gränser på applikationsnivå är användbara för att förhindra intern resursutmattning och för att göra applikationen mer robust. Ofta används en kombination av dessa metoder för en omfattande resurshanteringsstrategi.
