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 für einen Großteil des Mehrwerts ab, einschließlich Windows Update und automatischer Datenträgerdefragmentierung sowie Antivirenupdates und -überprüfungen. Darüber hinaus verwenden Unternehmen häufig Wartungsaktivitäten wie die Überprüfung des Netzwerkzugriffsschutzes (Network Access Protection, NAP), um Sicherheitsstandards auf allen Unternehmensarbeitsstationen durchzusetzen.

Wartungsaktivitäten in Windows sind so konzipiert, dass sie im Hintergrund mit eingeschränkter Benutzerinteraktion und minimalen Auswirkungen auf Leistung und Energieeffizienz ausgeführt werden. In Windows 7 und früheren Versionen sind die Leistung und Energieeffizienz jedoch aufgrund des nicht deterministischen und sehr unterschiedlichen Zeitplans der zahlreichen Wartungsaktivitäten in Windows weiterhin beeinträchtigt. Die Reaktionsfähigkeit für Benutzer wird reduziert, wenn wartungsaktivitäten ausgeführt werden, während Benutzer den Computer aktiv verwenden. Apps fordern den Benutzer auch häufig auf, seine Software zu aktualisieren und Hintergrundwartung auszuführen, und leiten Benutzer zu mehreren Umgebungen weiter, einschließlich Info-Center, Systemsteuerung, Windows Update, MmC-Snap-Ins für Aufgabenplanung und Steuerelemente von Drittanbietern.

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

Zentrale Probleme

Die automatische Wartung wurde entwickelt, um diese Probleme mit Wartungsaktivitäten in Windows zu beheben:

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

Funktionalität

Die automatische Wartung erleichtert die Effizienz im Leerlauf und ermöglicht eine zeitnahe und priorisierte Ausführung aller Aktivitäten. Darüber hinaus ermöglicht dies eine einheitliche Sichtbarkeit und Kontrolle über Wartungsaktivitäten und ermöglicht es Drittanbietern, ihre Wartungsaktivitäten zu Windows hinzuzufügen, ohne dass sich dies negativ auf Leistung und Energieeffizienz auswirkt. Dazu bietet es einen vollautomatischen Modus, einen vom Benutzer initiierten Modus, einen automatischen Stopp, Fristen und Benachrichtigungen sowie unternehmensweite Steuerung. Diese werden jeweils unten beschrieben.

Vollautomatischer Modus

Dieser Standardmodus ermöglicht eine intelligente Planung im Leerlauf des PCs 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 im Hintergrund ausgeführt.

Der Computer wird automatisch aus dem Standbymodus fortgesetzt, wenn das System wahrscheinlich nicht verwendet wird, wobei die Energieverwaltungsrichtlinie berücksichtigt wird, die im Fall von Laptops standardmäßig nur bei Netzstrom aktiviert wird. Vollständige Systemressourcen mit hoher Leistung werden verwendet, um die Wartungsaktivität so schnell wie möglich abzuschließen. Wenn das System für automatische Wartung aus dem Ruhezustand fortgesetzt wurde, wird aufgefordert, in den 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 Benutzer sich auf die Reise vorbereiten müssen, mit einer längeren Akkulaufzeit rechnen oder die Leistung und Reaktionsfähigkeit optimieren möchten, haben sie die Möglichkeit, die automatische Wartung bei Bedarf zu initiieren. Benutzer können Attribute für die automatische Wartung konfigurieren, einschließlich des Zeitplans für die automatische Ausführung. Sie können die aktuelle status der Ausführung der automatischen Wartung anzeigen und die automatische Wartung bei Bedarf beenden.

Automatisches Beenden

Die automatische Wartung beendet automatisch die laufenden Wartungsaktivitäten, wenn der Benutzer mit der Interaktion mit dem Computer beginnt. Die Wartungsaktivität wird fortgesetzt, wenn das System in den Leerlauf status zurückkehrt.

Hinweis

Alle Aktivitäten in der automatischen Wartung müssen das Beenden in zwei 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 Aufgaben nicht innerhalb der vorgesehenen Zeit ausgeführt werden konnten, beginnt die automatische Wartung automatisch bei der nächsten verfügbaren Gelegenheit zum System im Leerlauf. Wenn der Vorgangsstatus jedoch hinter der Frist zurückbleibt, benachrichtigt die automatische Wartung den Benutzer über die Aktivität und stellt eine Option für eine manuelle Ausführung der automatischen Wartung bereit. Alle für die Wartung geplanten Aufgaben werden ausgeführt, obwohl die am 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 darüber, dass kritische Wartungsaktivitäten ausgeführt werden.

Unternehmenssteuerung

IT-Experten im Unternehmen sollten in der Lage sein, zu bestimmen, wann die automatische Wartung auf ihren Windows-Systemen ausgeführt wird, diesen Zeitplan über standardisierte Verwaltungsschnittstellen zu erzwingen und Ereignisdaten über die status von Ausführungsversuchen für automatische Wartung abzurufen. Darüber hinaus sollten IT-Experten in der Lage sein, bestimmte Automatische Wartungsaktivitäten remote über Standardverwaltungsschnittstellen aufzurufen. Bei jeder Ausführung der automatischen Wartung wird status Berichterstellung ausgeführt, einschließlich Benachrichtigungen, wenn die automatische Wartung nicht ausgeführt werden konnte, weil der Benutzer die Aktivität manuell angehalten hat. IT-Experten sollten die Umstellung von Anmeldeskripts auf automatische Wartung erwägen, um die Anmeldeerfahrung des Benutzers schneller zu gestalten.

Erstellen einer Automatischen Wartungsaufgabe

In diesem Abschnitt erfahren Sie, wie Entwickler eine Aufgabe mithilfe einer Aufgabendefinition in XML oder C erstellen können. Beachten Sie, dass die Wartungsaktivität keine Benutzeroberfläche starten sollte, die eine Benutzerinteraktion erfordert, da die automatische Wartung völlig unbeaufsichtigt ist und ausgeführt wird, wenn der Benutzer nicht anwesend ist. Wenn der Benutzer während der automatischen Wartung mit dem Computer interagiert, werden alle laufenden Aufgaben bis zum nächsten Leerlauf beendet.

Verwenden von XML

Der Taskplaner enthält ein integriertes Befehlszeilentool, schtasks.exe, mit dem eine Aufgabendefinition im XML-Format importiert werden kann. Das Schema für die Aufgabendefinition ist unter https://msdn.microsoft.com/library/aa383609(v=VS.85).aspxdokumentiert. Im Folgenden finden Sie ein Beispiel für einen in XML definierten Task für die automatische Wartung.

<?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 die folgende Befehlszeile:

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

Verwenden von C

Ein Task für die automatische Wartung kann auch mit C-Code erstellt werden. Im Folgenden finden Sie ein Codebeispiel, das zum Konfigurieren der Einstellungen für die automatische Wartung einer Aufgabe 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 Aufgaben

Überprüfen Sie, ob der Task erfolgreich erstellt wurde und im Rahmen 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 Aufgabendefinition erwartungsgemäß erfolgt:

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

Überprüfen der Aufgabenausführung

Führen Sie diese Befehlszeile aus, um den Task zu starten und zu überprüfen, ob die Taskplaner-Benutzeroberfläche (taskschd.msc) zeigt, dass der Task ausgeführt wurde:

Schtasks.exe /Run /tn<task name>

Ressourcen

• Aufgabenplan 2.0