Manutenzione automatica
Piattaforme
Client : Windows 8
Server : Windows Server 2012
Descrizione
Windows dipende dall'esecuzione dell'attività di manutenzione posta in arrivo e di terze parti per gran parte del relativo valore aggiuntivo, tra cui Windows Update e deframmentazione automatica del disco, nonché aggiornamenti e analisi antivirus. Inoltre, le aziende usano spesso attività di manutenzione, ad esempio l'analisi protezione accesso alla rete per applicare gli standard di sicurezza in tutte le workstation aziendali.
L'attività di manutenzione in Windows è progettata per l'esecuzione in background con un'interazione utente limitata e un impatto minimo sulle prestazioni e sull'efficienza energetica. Tuttavia, in Windows 7 e versioni precedenti, le prestazioni e l'efficienza energetica sono ancora influenzate a causa della pianificazione non deterministica e ampiamente variata delle più attività di manutenzione in Windows. La velocità di risposta agli utenti viene ridotta quando viene eseguita l'attività di manutenzione mentre gli utenti usano attivamente il computer. Le app chiedono spesso all'utente di aggiornare il software ed eseguire la manutenzione in background e indirizzare gli utenti a più esperienze, tra cui Centro azioni, Pannello di controllo, Windows Update, snap-in MMC dell'utilità di pianificazione attività e controlli di terze parti.
L'obiettivo della manutenzione automatica consiste nel combinare tutte le attività di manutenzione in background in Windows e aiutare gli sviluppatori di terze parti ad aggiungere l'attività di manutenzione a Windows senza influire negativamente sulle prestazioni e sull'efficienza energetica. La manutenzione automatica consente inoltre agli utenti e alle aziende di controllare la pianificazione e la configurazione delle attività di manutenzione.
Problemi chiave
La manutenzione automatica è progettata per risolvere questi problemi con l'attività di manutenzione in Windows:
- Pianificazione della scadenza
- Conflitti di utilizzo delle risorse
- Efficienza energetica
- Trasparenza per l'utente
Funzionalità
La manutenzione automatica facilita l'efficienza inattiva e consente a tutte le attività di eseguire in modo tempestivo e prioritario. Consente inoltre di abilitare visibilità unificata e controllare l'attività di manutenzione e consente agli sviluppatori di terze parti di aggiungere l'attività di manutenzione a Windows senza influire negativamente sulle prestazioni e sull'efficienza energetica. A tale scopo, fornisce una modalità completamente automatica, modalità avviata dall'utente, arresto automatico, scadenze e notifica e controllo aziendale. Questi sono tutti descritti di seguito.
Modalità completamente automatica
Questa modalità predefinita consente la pianificazione intelligente durante l'inattività del PC e in orari pianificati, l'esecuzione e la sospensione automatica dell'attività di manutenzione senza alcun intervento dell'utente. L'utente può impostare una pianificazione settimanale o giornaliera. Tutte le attività di manutenzione non sono interattive ed vengono eseguite in modo invisibile all'utente.
Il computer viene ripreso automaticamente dalla sospensione quando il sistema non è probabile che sia in uso, rispettando i criteri di Risparmio energia, che nel caso dei portatili, le impostazioni predefinite consentono la riattivazione solo se è in alimentazione AC. Le risorse di sistema complete ad alta potenza vengono usate per completare l'attività di manutenzione il più rapidamente possibile. Se il sistema è stato ripreso dalla sospensione per la manutenzione automatica, viene richiesto di tornare al sonno.
Tutte le interazioni utente necessarie correlate alle attività, ad esempio la configurazione, vengono eseguite all'esterno dell'esecuzione automatica della manutenzione.
Modalità avviata dall'utente
Se gli utenti devono prepararsi per il viaggio, aspettarsi di essere in alimentazione della batteria per un tempo prolungato o desiderano ottimizzare le prestazioni e la velocità di risposta, hanno l'opzione di avviare la manutenzione automatica su richiesta. Gli utenti possono configurare gli attributi di manutenzione automatica, inclusa la pianificazione di esecuzione automatica. Possono visualizzare lo stato corrente dell'esecuzione automatica della manutenzione e possono arrestare la manutenzione automatica, se necessario.
Arresto automatico
La manutenzione automatica arresta automaticamente le attività di manutenzione se l'utente inizia a interagire con il computer. L'attività di manutenzione riprenderà quando il sistema restituisce lo stato inattiva.
Nota
Tutte le attività nella manutenzione automatica devono supportare l'arresto in 2 secondi o meno. L'utente deve ricevere una notifica che l'attività è stata arrestata.
Scadenze e notifiche
L'attività di manutenzione critica deve essere eseguita all'interno di un intervallo di tempo predefinito. Se le attività critiche non sono state in grado di eseguire entro il tempo designato, la manutenzione automatica inizierà automaticamente l'esecuzione all'opportunità successiva di inattività del sistema disponibile. Tuttavia, se lo stato dell'attività rimane al di sotto della scadenza, la manutenzione automatica avvisa l'utente dell'attività e fornisce un'opzione per un'esecuzione manuale della manutenzione automatica. Tutte le attività pianificate per la manutenzione verranno eseguite, anche se le attività più affamate hanno la precedenza. Questa attività può influire sulla velocità di risposta e sulle prestazioni del sistema; pertanto, la manutenzione automatica avvisa l'utente che l'attività di manutenzione critica è in esecuzione.
Controllo organizzazione
I professionisti IT aziendali devono essere in grado di determinare quando la manutenzione automatica viene eseguita nei sistemi Windows, applicare tale pianificazione tramite interfacce di gestione standardizzate e recuperare i dati sugli eventi relativi allo stato dei tentativi di esecuzione automatica della manutenzione. Inoltre, i professionisti IT devono essere in grado di richiamare attività di manutenzione automatica specifiche in remoto tramite interfacce di gestione standard. Ogni volta che la manutenzione automatica viene eseguita, la segnalazione dello stato, incluse le notifiche quando la manutenzione automatica non può essere eseguita perché l'utente ha sospeso manualmente l'attività, viene eseguita. I professionisti IT devono prendere in considerazione lo spostamento degli script di accesso in Manutenzione automatica per rendere più veloce l'esperienza di accesso dell'utente.
Creazione di un'attività di manutenzione automatica
Questa sezione illustra in dettaglio come gli sviluppatori possono creare un'attività usando una definizione di attività nel linguaggio XML o C. Tenere presente che l'attività di manutenzione non deve avviare alcuna interfaccia utente che richiede l'interazione dell'utente, poiché la manutenzione automatica è completamente invisibile e viene eseguita quando l'utente non è presente. In effetti, se l'utente interagisce con il computer durante la manutenzione automatica, tutte le attività in fase di elaborazione verranno terminate fino al periodo di inattività successivo.
Uso di XML
Utilità di pianificazione include uno strumento da riga di comando predefinito, schtasks.exe, che può importare una definizione dell'attività in formato XML. Lo schema per la definizione dell'attività è documentato in https://msdn.microsoft.com/library/aa383609(v=VS.85).aspx. Di seguito è riportato un esempio di un'attività di manutenzione automatica definita in XML.
<?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>
Per salvare l'attività in un computer Windows, salvare il codice XML precedente come file di testo e usare questa riga di comando:
Schtasks.exe /create /tn <task name> /xml <text file name>
Uso di C
È anche possibile creare un'attività di manutenzione automatica usando il codice C. Di seguito è riportato un esempio di codice che può essere usato per configurare le impostazioni di manutenzione automatica di un'attività:
/********************************************************************
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;
}
Convalida delle attività
Verificare che l'attività sia stata creata correttamente ed eseguita come parte della manutenzione.
Convalida della creazione di attività
Usare questa riga di comando per esportare la definizione dell'attività in un file e assicurarsi che la definizione dell'attività sia come previsto:
Schtasks.exe /Query /tn<task name> /xml <text file name>
Convalida dell'esecuzione dell'attività
Eseguire questa riga di comando per avviare l'attività e verificare che l'interfaccia utente dell'utilità di pianificazione (taskschd.msc) mostri l'attività eseguita:
Schtasks.exe /Run /tn<task name>
Risorse