Pemeliharaan Otomatis
Platform
Klien – Windows 8
Server – Windows Server 2012
Deskripsi
Windows tergantung pada eksekusi kotak masuk dan aktivitas pemeliharaan pihak ketiga untuk sebagian besar nilai tambahnya, termasuk Windows Update, dan defragmentasi disk otomatis, serta pembaruan dan pemindaian antivirus. Selain itu, perusahaan sering menggunakan aktivitas pemeliharaan seperti pemindaian Perlindungan Akses Jaringan (NAP) untuk membantu menegakkan standar keamanan di semua stasiun kerja perusahaan.
Aktivitas pemeliharaan di Windows dirancang untuk berjalan di latar belakang dengan interaksi pengguna terbatas dan dampak minimal terhadap performa dan efisiensi energi. Namun, pada Windows 7 dan versi yang lebih lama, performa dan efisiensi energi masih terpengaruh karena jadwal yang tidak deterministik dan sangat bervariasi dari beberapa aktivitas pemeliharaan di Windows. Responsivitas terhadap pengguna berkurang saat aktivitas pemeliharaan berjalan saat pengguna secara aktif menggunakan komputer. Aplikasi juga sering meminta pengguna untuk memperbarui perangkat lunak mereka dan menjalankan pemeliharaan latar belakang, dan mengarahkan pengguna ke beberapa pengalaman, termasuk Pusat Tindakan, Panel Kontrol, Windows Update, snap-in MMC Penjadwal Tugas, dan kontrol pihak ketiga.
Tujuan Pemeliharaan Otomatis adalah untuk menggabungkan semua aktivitas pemeliharaan latar belakang di Windows dan membantu pengembang pihak ketiga menambahkan aktivitas pemeliharaan mereka ke Windows tanpa berdampak negatif pada performa dan efisiensi energi. Selain itu, Pemeliharaan Otomatis memungkinkan pengguna serta perusahaan untuk mengontrol penjadwalan dan konfigurasi aktivitas pemeliharaan.
Masalah utama
Pemeliharaan Otomatis dirancang untuk mengatasi masalah ini dengan aktivitas pemeliharaan di Windows:
- Penjadwalan tenggat waktu
- Konflik pemanfaatan sumber daya
- Efisiensi energi
- Transparansi kepada pengguna
Fungsionalitas
Pemeliharaan Otomatis memfasilitasi efisiensi diam dan memungkinkan semua aktivitas berjalan tepat waktu dan diprioritaskan. Ini juga membantu memungkinkan visibilitas terpadu dan kontrol atas aktivitas pemeliharaan, dan memungkinkan pengembang pihak ketiga untuk menambahkan aktivitas pemeliharaan mereka ke Windows tanpa berdampak negatif pada performa dan efisiensi energi. Untuk melakukan ini, ini menyediakan mode otomatis penuh, mode yang dimulai pengguna, penghentian otomatis, tenggat waktu dan pemberitahuan, dan kontrol perusahaan. Ini masing-masing dijelaskan di bawah ini.
Mode otomatis penuh
Mode default ini memungkinkan penjadwalan cerdas selama waktu diam PC dan pada waktu terjadwal—eksekusi dan jeda otomatis aktivitas pemeliharaan tanpa intervensi pengguna. Pengguna dapat mengatur jadwal mingguan atau harian. Semua aktivitas pemeliharaan tidak interaktif dan dijalankan secara diam-diam.
Komputer secara otomatis dilanjutkan dari tidur ketika sistem tidak mungkin digunakan, menghormati kebijakan Manajemen Daya, yang dalam kasus laptop, default untuk memungkinkan bangun hanya jika menggunakan daya AC. Sumber daya sistem penuh dengan daya tinggi digunakan untuk menyelesaikan aktivitas pemeliharaan secepat mungkin. Jika sistem dilanjutkan dari tidur untuk Pemeliharaan Otomatis, sistem diminta untuk kembali tidur.
Setiap interaksi pengguna yang diperlukan yang terkait dengan aktivitas seperti konfigurasi dilakukan di luar eksekusi Pemeliharaan Otomatis.
Mode yang dimulai pengguna
Jika pengguna perlu mempersiapkan perjalanan, berharap untuk menggunakan daya baterai untuk waktu yang lama, atau ingin mengoptimalkan performa dan responsivitas, mereka memiliki opsi untuk memulai Pemeliharaan Otomatis sesuai permintaan. Pengguna dapat mengonfigurasi atribut Pemeliharaan Otomatis, termasuk jadwal eksekusi otomatis. Mereka dapat melihat status eksekusi Pemeliharaan Otomatis saat ini, dan mereka dapat menghentikan Pemeliharaan Otomatis jika diperlukan.
Penghentian otomatis
Pemeliharaan Otomatis secara otomatis berhenti saat ini menjalankan aktivitas pemeliharaan jika pengguna mulai berinteraksi dengan komputer. Aktivitas pemeliharaan akan dilanjutkan ketika sistem kembali ke status diam.
Catatan
Semua aktivitas dalam Pemeliharaan Otomatis harus mendukung penghentian dalam 2 detik atau kurang. Pengguna harus diberi tahu bahwa aktivitas telah dihentikan.
Tenggat waktu dan pemberitahuan
Aktivitas pemeliharaan penting harus dijalankan dalam jendela waktu yang telah ditentukan sebelumnya. Jika tugas penting belum dapat berjalan dalam waktu yang ditentukan, Pemeliharaan Otomatis akan secara otomatis mulai dijalankan pada kesempatan menganggur sistem berikutnya yang tersedia. Namun, jika status tugas tetap berada di belakang tenggat waktu, Pemeliharaan Otomatis akan memberi tahu pengguna tentang aktivitas dan memberikan opsi untuk menjalankan Pemeliharaan Otomatis secara manual. Semua tugas yang dijadwalkan untuk pemeliharaan akan berjalan, meskipun tugas yang paling kelaparan lebih diutamakan. Aktivitas ini dapat berdampak pada responsivitas dan performa sistem; oleh karena itu, Pemeliharaan Otomatis akan memberi tahu pengguna bahwa aktivitas pemeliharaan penting sedang dijalankan.
Kontrol perusahaan
Profesional TI perusahaan harus dapat menentukan kapan Pemeliharaan Otomatis dijalankan pada sistem Windows mereka, memberlakukan jadwal tersebut melalui antarmuka manajemen standar, dan mengambil data peristiwa tentang status upaya eksekusi Pemeliharaan Otomatis. Selain itu, profesional TI harus dapat memanggil aktivitas Pemeliharaan Otomatis tertentu dari jarak jauh melalui antarmuka manajemen standar. Setiap kali Pemeliharaan Otomatis dijalankan, pelaporan status, termasuk pemberitahuan saat Pemeliharaan Otomatis tidak dapat dijalankan karena pengguna telah menjeda aktivitas secara manual, berjalan. Profesional TI harus mempertimbangkan untuk memindahkan skrip masuk ke Pemeliharaan Otomatis untuk membantu membuat pengalaman masuk pengguna lebih cepat.
Membuat tugas Pemeliharaan Otomatis
Bagian ini merinci bagaimana pengembang dapat membuat tugas menggunakan definisi tugas dalam bahasa XML atau C. Perlu diingat bahwa aktivitas pemeliharaan tidak boleh meluncurkan antarmuka pengguna apa pun yang memerlukan interaksi pengguna, karena Pemeliharaan Otomatis benar-benar diam dan berjalan ketika pengguna tidak ada. Memang, jika pengguna berinteraksi dengan komputer selama Pemeliharaan Otomatis, tugas apa pun yang sedang dalam proses akan berakhir hingga periode menganggur berikutnya.
Menggunakan XML
Task Scheduler menyertakan alat baris perintah bawaan, schtasks.exe, yang dapat mengimpor definisi tugas dalam format XML. Skema untuk definisi tugas di dokumentasikan di https://msdn.microsoft.com/library/aa383609(v=VS.85).aspx. Di bawah ini adalah contoh tugas Pemeliharaan Otomatis yang ditentukan dalam 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>
Untuk menyimpan tugas di komputer Windows, simpan XML di atas sebagai file teks dan gunakan baris perintah ini:
Schtasks.exe /create /tn <task name> /xml <text file name>
Menggunakan C
Tugas Pemeliharaan Otomatis juga dapat dibuat menggunakan kode C. Di bawah ini adalah sampel kode yang dapat digunakan untuk mengonfigurasi pengaturan Pemeliharaan Otomatis tugas:
/********************************************************************
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;
}
Memvalidasi tugas
Validasi bahwa tugas telah berhasil dibuat dan berjalan sebagai bagian dari pemeliharaan.
Memvalidasi pembuatan tugas
Gunakan baris perintah ini untuk mengekspor definisi tugas ke file dan memastikan bahwa definisi tugas seperti yang diharapkan:
Schtasks.exe /Query /tn<task name> /xml <text file name>
Memvalidasi eksekusi tugas
Jalankan baris perintah ini untuk meluncurkan tugas dan memvalidasi bahwa UI Penjadwal Tugas (taskschd.msc) menunjukkan tugas telah berjalan:
Schtasks.exe /Run /tn<task name>
Sumber