Automatische Wartung

Plattformen

Clients – Windows 8
Server – Windows Server 2012

Beschreibung

Windows hängt von der Ausführung von Posteingangs- und Wartungsaktivitäten von Drittanbietern ab, einschließlich Windows Update und automatischer Datenträgerdefragmentierung sowie Antivirenupdates und Scans. Darüber hinaus verwenden Unternehmen häufig Wartungsaktivitäten wie Netzwerkzugriffsschutz (NAP), um Sicherheitsstandards auf allen Unternehmensarbeitsstationen zu erzwingen.

Wartungsaktivitäten in Windows werden im Hintergrund mit eingeschränkter Benutzerinteraktion und minimalem Einfluss auf Leistung und Energieeffizienz ausgeführt. In Windows 7 und früheren Versionen sind die Leistung und Energieeffizienz jedoch aufgrund der nicht deterministischen und weit unterschiedlichen Wartungsaktivitäten in Windows weiterhin betroffen. Die Reaktionsfähigkeit der Benutzer wird reduziert, wenn Wartungsaktivitäten ausgeführt werden, während Benutzer aktiv den Computer verwenden. Apps bitten den Benutzer auch häufig, ihre Software zu aktualisieren und Hintergrundwartung auszuführen, und leiten Sie Benutzer auf mehrere Erfahrungen, einschließlich Action Center, Systemsteuerung, Windows Update, Aufgabenplaner MMC-Snap-Ins und Drittanbietersteuerelemente.

Das Ziel von Automatische Wartung besteht darin, alle Hintergrundwartungsaktivitäten in Windows zu kombinieren und Drittanbietern dabei zu helfen, ihre Wartungsaktivitäten zu Windows hinzuzufügen, ohne die Leistung und Energieeffizienz negativ zu beeinflussen. Darüber hinaus ermöglicht Automatische Wartung Benutzern sowie Unternehmen die Kontrolle über die Planung und Konfiguration von Wartungsaktivitäten.

Wichtige Probleme

Automatische Wartung soll diese Probleme mit Wartungsaktivitäten in Windows beheben:

  • Terminplanung
  • Ressourcenauslastungskonflikte
  • Energieeffizienz
  • Transparenz für den Benutzer

Funktionalität

Automatische Wartung erleichtert die Leerlaufeffizienz und ermöglicht es allen Aktivitäten, rechtzeitig und priorisiert zu laufen. Außerdem hilft es Entwicklern, die einheitliche Sichtbarkeit und Kontrolle über Wartungsaktivitäten zu ermöglichen und Drittanbietern das Hinzufügen ihrer Wartungsaktivitäten zu Windows, ohne die Leistung und Energieeffizienz negativ zu beeinflussen. Dazu stellt er einen voll automatischen Modus, einen vom Benutzer initiierten Modus, automatisches Beenden, Frist und Benachrichtigung und Unternehmenssteuerung bereit. Dies sind alle unten beschrieben.

Voll automatischer Modus

Dieser Standardmodus ermöglicht die intelligente Planung während der PC-Leerlaufzeit und zu geplanten Zeiten – die Ausführung und automatische Unterbrechung der Wartungsaktivität ohne Benutzereingriff. Der Benutzer kann einen wöchentlichen oder täglichen Zeitplan festlegen. Alle Wartungsaktivitäten sind nicht interaktiv und werden automatisch ausgeführt.

Der Computer wird automatisch aus dem Ruhezustand fortgesetzt, wenn das System nicht wahrscheinlich verwendet wird, was die Power Management-Richtlinie betrifft, die im Fall von Laptops standardmäßig die Aktivierung nur zulassen soll, wenn es sich um eine AC-Stromversorgung handelt. Vollständige Systemressourcen mit hoher Leistung werden verwendet, um die Wartungsaktivität so schnell wie möglich abzuschließen. Wenn das System vom Schlaf für Automatische Wartung fortgesetzt wurde, wird er aufgefordert, zum Schlaf zurückzukehren.

Alle erforderlichen Benutzerinteraktionen im Zusammenhang mit Aktivitäten wie der Konfiguration werden außerhalb der Automatische Wartung Ausführung ausgeführt.

Vom Benutzer initiierter Modus

Wenn Benutzer sich auf Reisen vorbereiten müssen, erwarten Sie, dass sie für eine längere Zeit auf Akkuleistung stehen oder die Leistung und Reaktionsfähigkeit optimieren möchten, haben sie die Möglichkeit, Automatische Wartung nach Bedarf zu initiieren. Benutzer können Automatische Wartung Attribute konfigurieren, einschließlich des zeitplans für die automatische Ausführung. Sie können den aktuellen Status der Automatische Wartung Ausführung anzeigen, und sie können bei Bedarf Automatische Wartung beenden.

Automatisches Beenden

Automatische Wartung führt derzeit Wartungsaktivitäten automatisch aus, wenn der Benutzer mit der Interaktion mit dem Computer beginnt. Die Wartungsaktivität wird fortgesetzt, wenn das System zum Leerlaufstatus zurückgibt.

Hinweis

Alle Aktivitäten in Automatische Wartung müssen den Stopp in 2 Sekunden oder weniger unterstützen. Der Benutzer sollte benachrichtigt werden, dass die Aktivität beendet wurde.

 

Frist und Benachrichtigung

Kritische Wartungsaktivitäten müssen innerhalb eines vordefinierten Zeitfensters ausgeführt werden. Wenn kritische Vorgänge innerhalb ihrer angegebenen Zeit nicht ausgeführt werden konnten, beginnt Automatische Wartung automatisch mit der Ausführung der nächsten verfügbaren System-Leerlaufchance. Wenn der Vorgangszustand jedoch hinter dem Stichtag bleibt, benachrichtigt Automatische Wartung den Benutzer über die Aktivität und stellt eine Option für eine manuelle Ausführung von Automatische Wartung bereit. Alle vorgänge, die für die Wartung geplant sind, werden ausgeführt, obwohl die meisten ausgehungerten Vorgänge Vorrang haben. Diese Aktivität kann sich auf die Reaktionsfähigkeit und Leistung des Systems auswirken; daher benachrichtigt Automatische Wartung den Benutzer, dass wichtige Wartungsaktivitäten ausgeführt werden.

Enterprise Steuerelement

Enterprise IT-Experten sollten bestimmen können, wann Automatische Wartung auf ihren Windows Systemen ausgeführt wird, diesen Zeitplan über standardisierte Verwaltungsschnittstellen erzwingen und Ereignisdaten über den Status von Automatische Wartung Ausführungsversuchen abrufen. Darüber hinaus sollten IT-Experten bestimmte Automatische Wartung Aktivitäten remote über Standardverwaltungsschnittstellen aufrufen können. Jedes Mal, wenn Automatische Wartung ausgeführt wird, werden statusberichte, einschließlich Benachrichtigungen, wenn Automatische Wartung nicht ausgeführt werden konnten, da der Benutzer die Aktivität manuell angehalten hat. IT-Experten sollten das Verschieben von Anmeldeskripts in Automatische Wartung berücksichtigen, um die Anmeldeerfahrung des Benutzers schneller zu gestalten.

Erstellen einer Automatische Wartung Aufgabe

In diesem Abschnitt erfahren Sie, wie Entwickler eine Aufgabe mithilfe einer Aufgabendefinition in XML- oder C-Sprache erstellen können. Beachten Sie, dass Wartungsaktivitäten keine Benutzeroberfläche starten sollten, die Benutzerinteraktion erfordert, da Automatische Wartung vollständig stumm ist und ausgeführt wird, wenn der Benutzer nicht vorhanden ist. Wenn der Benutzer während der Automatische Wartung mit dem Computer interagiert, werden alle Vorgänge im Prozess bis zum nächsten Leerlauf beendet.

Verwenden von XML

Aufgabenplaner enthält ein integriertes Befehlszeilentool, schtasks.exe, das eine Aufgabendefinition im XML-Format importieren kann. Das Schema für die Aufgabendefinition wird unter https://msdn.microsoft.com/library/aa383609(v=VS.85).aspxdokumentiert. Nachfolgend finden Sie ein Beispiel für eine in XML definierte Automatische Wartung Aufgabe.

<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Date>2011-07-01T11:34:31</Date>
    <Author>IT Deptartment</Author>
  </RegistrationInfo>
  <Principals>
    <Principal id="Author">
      <RunLevel>LeastPrivilege</RunLevel>
      <GroupId>NT AUTHORITY\SYSTEM</GroupId>
    </Principal>
  </Principals>
  <Settings>
    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <DisallowStartIfOnBatteries>true</DisallowStartIfOnBatteries>
    <StopIfGoingOnBatteries>true</StopIfGoingOnBatteries>
    <AllowHardTerminate>true</AllowHardTerminate>
    <StartWhenAvailable>false</StartWhenAvailable>
    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
    <MaintenanceSettings>
      <Period>P2D</Period>
      <Deadline>P14D</Deadline>
    </MaintenanceSettings>
    <AllowStartOnDemand>true</AllowStartOnDemand>
    <Enabled>true</Enabled>
    <Hidden>false</Hidden>
    <RunOnlyIfIdle>false</RunOnlyIfIdle>
    <DisallowStartOnRemoteAppSession>false</DisallowStartOnRemoteAppSession>
    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>
    <WakeToRun>false</WakeToRun>
    <ExecutionTimeLimit>P3D</ExecutionTimeLimit>
    <Priority>7</Priority>
  </Settings>
  <Actions Context="Author">
    <Exec>
      <Command>cmd</Command>
      <Arguments>/c timeout -t 60</Arguments>
    </Exec>
  </Actions>
</Task> 

Um die Aufgabe auf einem Windows Computer zu speichern, speichern Sie die obige XML-Datei als Textdatei und verwenden Sie diese Befehlszeile:

Schtasks.exe /create /tn <task name> /xml <text file name>

Verwenden von C

Eine Automatische Wartung Aufgabe kann auch mithilfe von C-Code erstellt werden. Nachfolgend finden Sie ein Codebeispiel, das zum Konfigurieren der Automatische Wartung Einstellungen eines Vorgangs verwendet werden kann:

/********************************************************************
This sample creates a maintenance task to start cmd window during maintenance opportunities with periodicity of 2 days and deadline 0f 14 days.
********************************************************************/

#define _WIN32_DCOM

#include <windows.h>
#include <iostream>
#include <stdio.h>
#include <comdef.h>
#include <wincred.h>
//  Include the task header file.
#include <taskschd.h>
//#pragma comment(lib, "taskschd.lib")
//#pragma comment(lib, "comsupp.lib")

int __cdecl 
MainteanceTask( )
{
    //  ------------------------------------------------------
    //  Initialize COM.
    HRESULT hr;

    //  ------------------------------------------------------
    //  Create a name for the task.
    LPCWSTR wszTaskName = L"MaintenanceTask";

    ITaskService *pService = NULL;
    ITaskFolder *pRootFolder = NULL;
    ITaskDefinition *pTask = NULL;
    ITaskSettings *pSettings = NULL;
    IRegistrationInfo *pRegInfo= NULL;
    IPrincipal *pPrincipal = NULL;
    ITaskSettings3 *pSettings3 = NULL;
    IMaintenanceSettings* pMaintenanceSettings = NULL;
    IActionCollection *pActionCollection = NULL;
    IAction *pAction = NULL;
    IExecAction *pExecAction = NULL;
    IRegisteredTask *pRegisteredTask = NULL;

    wprintf(L"\nCreate Maintenance Task %ws", wszTaskName );

    hr = CoInitializeEx( NULL, COINIT_MULTITHREADED);
    if( FAILED(hr) )
    {
        wprintf(L"\nCoInitializeEx failed: %x", hr );
        return 1;
    }

    //  Set general COM security levels.
    hr = CoInitializeSecurity( NULL,
        -1,
        NULL,
        NULL,
        RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
        RPC_C_IMP_LEVEL_IMPERSONATE,
        NULL,
        0,
        NULL);

    if( FAILED(hr) )
    {
        wprintf(L"\nCoInitializeSecurity failed: %x", hr );
        goto CleanUp;
    }

    //  ------------------------------------------------------
    //  Create an instance of the Task Service. 
    hr = CoCreateInstance( CLSID_TaskScheduler,
                           NULL,
                           CLSCTX_INPROC_SERVER,
                           IID_ITaskService,
                           (void**)&pService );  
    if (FAILED(hr))
    {
        wprintf(L"\nFailed to create an instance of ITaskService: %x", hr);
        goto CleanUp;
    }
        
    //  Connect to the task service.
    hr = pService->Connect(_variant_t(), _variant_t(), _variant_t(), _variant_t());
    if( FAILED(hr) )
    {
        wprintf(L"\nITaskService::Connect failed: %x", hr );
        goto CleanUp;
    }

    //  ------------------------------------------------------
    //  Get the pointer to the root task folder.  This folder will hold the
    //  new task that is registered.
    hr = pService->GetFolder( _bstr_t( L"\\") , &pRootFolder );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot get Root folder pointer: %x", hr );
        goto CleanUp;
    }
    
    //  If the same task exists, remove it.
    ( void ) pRootFolder->DeleteTask( _bstr_t(wszTaskName), 0  );
    
    //  Create the task definition object to create the task.
    hr = pService->NewTask( 0, &pTask );
    if (FAILED(hr))
    {
        wprintf(L"\nFailed to CoCreate an instance of the TaskService class: %x", hr);
        goto CleanUp;
    }
        
    //  ------------------------------------------------------
    //  Get the registration info for setting the identification.
    hr = pTask->get_RegistrationInfo( &pRegInfo );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot get identification pointer: %x", hr );
        goto CleanUp;
    }
    
    hr = pRegInfo->put_Author( _bstr_t(L"Author Name") );    
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot put identification info: %x", hr );
        goto CleanUp;
    }

    // The task needs to grant explicit FRFX to LOCAL SERVICE (A;;FRFX;;;LS)
    hr = pRegInfo->put_SecurityDescriptor( _variant_t(L"D:P(A;;FA;;;BA)(A;;FA;;;SY)(A;;FRFX;;;LS)") );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot put security descriptor: %x", hr );
        goto CleanUp;
    }

    //  ------------------------------------------------------
    //  Create the principal for the task - these credentials
    //  are overwritten with the credentials passed to RegisterTaskDefinition
    hr = pTask->get_Principal( &pPrincipal );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot get principal pointer: %x", hr );
        goto CleanUp;
    }
    
    //  Set up principal logon type to interactive logon
    hr = pPrincipal->put_LogonType( TASK_LOGON_INTERACTIVE_TOKEN );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot put principal info: %x", hr );
        goto CleanUp;
    }  

    //  ------------------------------------------------------
    //  Create the settings for the task
    hr = pTask->get_Settings( &pSettings );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot get settings pointer: %x", hr );
        goto CleanUp;
    }

    hr = pSettings->QueryInterface( __uuidof(ITaskSettings3), (void**) &pSettings3 );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot query ITaskSettings3 interface: %x", hr );
        goto CleanUp;
    }

    hr = pSettings3->put_UseUnifiedSchedulingEngine( VARIANT_TRUE );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot put_UseUnifiedSchedulingEngine: %x", hr );
        goto CleanUp;
    }

    hr = pSettings3->CreateMaintenanceSettings( &pMaintenanceSettings );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot CreateMaintenanceSettings: %x", hr );
        goto CleanUp;
    }

    hr = pMaintenanceSettings->put_Period ( _bstr_t(L"P2D") );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot put_Period: %x", hr );
        goto CleanUp;
    }

    hr = pMaintenanceSettings->put_Deadline ( _bstr_t(L"P14D") );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot put_Period: %x", hr );
        goto CleanUp;
    }

    //  ------------------------------------------------------
    //  Add an action to the task. This task will execute cmd.exe.     
    //  Get the task action collection pointer.
    hr = pTask->get_Actions( &pActionCollection );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot get Task collection pointer: %x", hr );
        goto CleanUp;
    }
    
    //  Create the action, specifying that it is an executable action.
    hr = pActionCollection->Create( TASK_ACTION_EXEC, &pAction );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot create the action: %x", hr );
        goto CleanUp;
    }

    //  QI for the executable task pointer.
    hr = pAction->QueryInterface( IID_IExecAction, (void**) &pExecAction );
    if( FAILED(hr) )
    {
        wprintf(L"\nQueryInterface call failed for IExecAction: %x", hr );
        goto CleanUp;
    }

    //  Set the path of the executable to cmd.exe.
    hr = pExecAction->put_Path( _bstr_t(L"cmd") );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot put action path: %x", hr );
        goto CleanUp;
    }  
    
    //  ------------------------------------------------------
    //  Save the task in the root folder.
    hr = pRootFolder->RegisterTaskDefinition(
            _bstr_t(wszTaskName),
            pTask,
            TASK_CREATE_OR_UPDATE, 
            _variant_t(), 
            _variant_t(), 
            TASK_LOGON_INTERACTIVE_TOKEN,
            _variant_t(L""),
            &pRegisteredTask);
    if( FAILED(hr) )
    {
        wprintf(L"\nError saving the Task : %x", hr );
        goto CleanUp;
    }
    
    wprintf(L"\nSuccess!\n----------------------------------" );

CleanUp:

    if ( pService != NULL ) pService->Release();
    if ( pRootFolder != NULL ) pRootFolder->Release();
    if ( pTask != NULL ) pTask->Release();
    if ( pSettings != NULL ) pSettings->Release();
    if ( pRegInfo != NULL ) pRegInfo->Release();
    if ( pPrincipal != NULL ) pPrincipal->Release();
    if ( pSettings3 != NULL ) pSettings3->Release();
    if ( pMaintenanceSettings != NULL ) pMaintenanceSettings->Release();
    if ( pActionCollection != NULL ) pActionCollection->Release();
    if ( pAction != NULL ) pAction->Release();
    if ( pExecAction != NULL ) pExecAction->Release();
    if ( pRegisteredTask != NULL ) pRegisteredTask->Release();

    CoUninitialize();
    return SUCCEEDED ( hr ) ? 0 : 1;
}

Überprüfen von Vorgängen

Überprüfen Sie, ob die Aufgabe erfolgreich erstellt wurde und als Teil der Wartung ausgeführt wird.

Überprüfen der Vorgangserstellung

Verwenden Sie diese Befehlszeile, um die Aufgabendefinition in eine Datei zu exportieren und sicherzustellen, dass die Aufgabendefinition wie erwartet ist:

Schtasks.exe /Query /tn<task name> /xml <text file name>

Überprüfen der Vorgangsausführung

Führen Sie diese Befehlszeile aus, um die Aufgabe zu starten und zu überprüfen, ob die Taskplaner-UI (taskschd.msc) die Ausführung der Aufgabe anzeigt:

Schtasks.exe /Run /tn<task name>

Ressourcen