Automatische Wartung

Plattformen

Clients – Windows 8 Server – Windows Server 2012

Beschreibung

Windows hängt von der Ausführung von Posteingangs- und Drittanbieterwartungsaktivitäten für einen Großteil seines Wert-Adds 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 sollen im Hintergrund mit eingeschränkter Benutzerinteraktion und minimalen Auswirkungen auf Leistung und Energieeffizienz ausgeführt werden. In Windows 7 und früheren Versionen wirkt sich die Leistung und Energieeffizienz jedoch aufgrund des nicht deterministischen und weit unterschiedlichen Zeitplans der mehrfachen Wartungsaktivitäten in Windows weiterhin aus. 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, seine Software zu aktualisieren und Hintergrundwartung auszuführen, und leitet Benutzer zu mehreren Erfahrungen, einschließlich Info Center, Systemsteuerung, Windows Update, Aufgabenplaner MMC-Snap-In und Steuerelemente von Drittanbietern.

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

Wichtige Probleme

Die automatische Wartung ist so konzipiert, dass diese Probleme mit Wartungsaktivitäten in Windows behoben werden:

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

Funktionalität

Die automatische Wartung erleichtert die Effizienz im Leerlauf und ermöglicht es allen Aktivitäten, rechtzeitig und priorisiert zu laufen. Außerdem können Entwickler von Drittanbietern ihre Wartungsaktivitäten durch einheitliche Sichtbarkeit und Kontrolle über Wartungsaktivitäten aktivieren und ihre Wartungsaktivitäten zu Windows hinzufügen, ohne die Leistung und Energieeffizienz negativ zu beeinträchtigen. Dazu wird ein vollautomatisierter Modus, ein vom Benutzer initiierter Modus, ein automatischer Stopp, Stichtage und Benachrichtigungen sowie eine Unternehmenssteuerung bereitgestellt. Dies sind alle unten beschrieben.

Vollautomatisierter 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 wahrscheinlich nicht verwendet wird, wobei die Power Management-Richtlinie beachtet wird, die im Fall von Laptops standardmäßig nur aktiviert wird, wenn es sich um eine Netzstromleistung handelt. Vollständige Systemressourcen mit hoher Leistung werden verwendet, um die Wartungsaktivität so schnell wie möglich abzuschließen. Wenn das System aus dem Ruhezustand für die automatische Wartung fortgesetzt wurde, wird er aufgefordert, zum Ruhezustand zurückzukehren.

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

Vom Benutzer initiierter Modus

Wenn Sich die Benutzer auf Reisen vorbereiten müssen, erwarten Sie, dass sie längere Zeit auf Akkustrom sind oder die Leistung und Reaktionsfähigkeit optimieren möchten, haben sie die Möglichkeit, die automatische Wartung bei Bedarf zu initiieren. Benutzer können automatische Wartungsattribute konfigurieren, einschließlich des Zeitplans für die automatische Ausführung. Sie können den aktuellen Status der ausführung der automatischen Wartung anzeigen und bei Bedarf die automatische Wartung beenden.

Automatisches Beenden

Die automatische Wartung beendet derzeit die Wartungsaktivitäten, wenn der Benutzer mit der Interaktion mit dem Computer beginnt. Die Wartungsaktivität wird fortgesetzt, wenn das System zum Leerlaufstatus zurückkehrt.

Hinweis

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

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

Unternehmenssteuerung

Unternehmens-IT-Experten sollten in der Lage sein, festzustellen, wann die automatische Wartung auf ihren Windows-Systemen ausgeführt wird, diesen Zeitplan über standardisierte Verwaltungsschnittstellen erzwingen und Ereignisdaten über den Status der Automatischen Wartungsausführungsversuche abrufen. Darüber hinaus sollten IT-Experten in der Lage sein, bestimmte automatische Wartungsaktivitäten remote über Standardverwaltungsschnittstellen aufzurufen. Jedes Mal, wenn die automatische Wartung ausgeführt wird, werden Statusberichte, einschließlich Benachrichtigungen, wenn die automatische Wartung nicht ausgeführt werden konnte, da der Benutzer die Aktivität manuell angehalten hat, ausgeführt wird. IT-Experten sollten das Verschieben von Anmeldeskripts auf die automatische Wartung erwägen, um die Anmeldeerfahrung des Benutzers schneller zu gestalten.

Erstellen einer automatischen Wartungsaufgabe

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

Verwenden von XML

Task Scheduler enthält ein integriertes Befehlszeilentool, schtasks.exe, das eine Aufgabendefinition im XML-Format importieren kann. Das Schema für die Vorgangsdefinition wird unter https://msdn.microsoft.com/library/aa383609(v=VS.85).aspx" dokumentiert. Nachfolgend finden Sie ein Beispiel für einen in XML definierten Vorgang für die automatische Wartung.

<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.4" xmlns="https://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 den obigen XML-Code als Textdatei, und verwenden Sie diese Befehlszeile:

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

Verwenden von C

Eine Aufgabe für die automatische Wartung kann auch mit C-Code erstellt werden. Nachfolgend finden Sie ein Codebeispiel, das zum Konfigurieren der Einstellungen für die automatische Wartung 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**)&amp;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"\\") , &amp;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, &amp;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( &amp;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( &amp;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( &amp;pSettings );
    if( FAILED(hr) )
    {
        wprintf(L"\nCannot get settings pointer: %x", hr );
        goto CleanUp;
    }

    hr = pSettings->QueryInterface( __uuidof(ITaskSettings3), (void**) &amp;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( &amp;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 notepad.exe.     
    //  Get the task action collection pointer.
    hr = pTask->get_Actions( &amp;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, &amp;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**) &amp;pExecAction );
    if( FAILED(hr) )
    {
        wprintf(L"\nQueryInterface call failed for IExecAction: %x", hr );
        goto CleanUp;
    }

    //  Set the path of the executable to notepad.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""),
            &amp;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 Aufgaben

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

Überprüfen der Erstellung von Aufgaben

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

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

Überprüfen der Vorgangsausführung

Führen Sie diese Befehlszeile aus, um den Vorgang zu starten und zu überprüfen, ob die Task Scheduler UI (taskschd.msc) die Ausführung des Vorgangs anzeigt:

Schtasks.exe /Run /tn<task name>

Ressourcen

• Vorgangszeitplan 2.0