Bajo qué usuario se inician los servicios en Windows. Servicios de Windows. que son los servicios

Modos de funcionamiento

En la mayoría de los casos, los servicios tienen prohibido interactuar con la consola o el escritorio de los usuarios (tanto locales como remotos), sin embargo, para algunos servicios, es posible una excepción: interacción con la consola (número de sesión 0, en el que el usuario inicia sesión localmente o cuando se inicia el servicio mstsc con la tecla /consola).

Hay varios modos para los servicios:

  • prohibido lanzar;
  • arranque manual (bajo pedido);
  • inicio automático cuando la computadora arranca;
  • inicio automático (retrasado) (introducido en Windows Vista y Windows Server 2008);
  • servicio/controlador requerido (arranque automático e incapacidad (para el usuario) de detener el servicio).

modo de fondo

Iniciar, detener y cambiar los servicios de Windows

Los servicios y sus atributos se pueden cambiar en MMC:

En varias versiones sistemas operativos Algunos servicios pueden estar presentes y otros no. Algunas aplicaciones y programas instalados por separado también pueden crear sus propios servicios.

Lista de servicios del sistema operativo Microsoft Windows

Nombre para mostrar Nombre del Servicio Funciones Descripción
cliente DHCP dhcp Registra y actualiza las direcciones IP y los registros DNS para esta computadora. Si se detiene este servicio, esta computadora no podrá obtener direcciones IP dinámicas ni realizar actualizaciones de DNS.
cliente DNS dnscaché El servicio de cliente DNS (dnscache) almacena en caché los nombres DNS (Sistema de nombres de dominio) y registra el nombre completo este computador. Si se detiene el servicio, la resolución de nombres DNS continuará. Sin embargo, los resultados de las colas de nombres DNS no se almacenarán en caché y el nombre de la computadora no se registrará.
KtmRm para coordinador de transacciones distribuidas KtmRm Coordina las transacciones entre MSDTC y Kernel Transaction Manager (KTM).
ListoBoost EMDMgmt ListoBoost Soporte para mejorar el rendimiento del sistema con la tecnología ReadyBoost.
Superfetch Sistema principal Superfetch Mantiene y mejora el rendimiento del sistema.
Sonido de Windows Audiosrv Gestión de audio para programas de windows. Si se detiene este servicio, los dispositivos y efectos de audio no funcionarán correctamente.
Espacio de tarjeta de Windows idsvc Proporciona una forma segura de crear, administrar y exponer identidades digitales.
Actualización automática WUAUSERV Incluye descarga e instalación. actualizaciones de windows. Si el servicio está deshabilitado, no podrá usar las funciones en esta computadora. Actualización automática o el sitio web de Windows Update.

Lista de servicios creados por aplicaciones y programas de Microsoft

Lista de servicios creados por aplicaciones y programas de terceros

ver también

Lista de servicios de Windows

Enlaces

  • pcs.suite101.com/article.cfm/index_of_services: Índice de servicios de Windows XP: un índice de los servicios que se ejecutan en Windows XP Sistema operativo
  • Cómo eliminar un servicio Windows Vista o Windows XP
  • Servicios de Windows XP (ruso)

Fundación Wikimedia. 2010 .

Vea qué es "Servicios de Windows" en otros diccionarios:

    Servicios de Windows SharePoint (WSS) complemento gratuito a Microsoft Windows Server 2003 y 2008, que implementa una plataforma web completa con soporte para las siguientes funciones: Sistema de administración de contenido Herramientas de colaboración ... ... Wikipedia

    Familia de sistemas operativos Windows para desarrolladores de Microsoft ... Wikipedia

    Componente de Microsoft Windows ... Wikipedia


El servicio de Windows NT (servicio de Windows NT) es un proceso especial que tiene una interfaz unificada para interactuar con el sistema operativo. sistema de ventanas NUEVO TESTAMENTO. Los servicios se dividen en dos tipos: servicios Win32 que interactúan con el sistema operativo a través del Administrador de control de servicios (SCM) y controladores que funcionan con el protocolo del controlador. Dispositivos Windows NUEVO TESTAMENTO. En el resto de este artículo, solo hablaremos de los servicios de Win32.

Aplicación de servicios

Una de las propiedades más importantes de un servicio es la no interactividad. Un servicio típico se ejecuta en segundo plano, invisible para el usuario promedio. Debido a esto, los servicios son más adecuados para implementar los siguientes tipos de aplicaciones:

  • Servidores en arquitectura cliente-servidor (por ejemplo, MS SQL, MS Exchange Server)
  • Red servicios de ventanas NT (servidor, estación de trabajo);
  • Servidor (en el sentido de funcionalidad) componentes de aplicaciones distribuidas (por ejemplo, varios programas de monitoreo).

Propiedades básicas de los servicios.

Un servicio se diferencia de una aplicación Win32 normal en 3 formas principales. Consideremos cada uno de ellos.

En primer lugar, es la capacidad de detener (suspender) el servicio con gracia. El usuario u otra aplicación que utiliza mecanismos estándar tiene la capacidad de cambiar el estado del servicio, pasarlo del estado de ejecución al estado de pausa, o incluso detener su funcionamiento. En este caso, antes de cambiar su estado, el servicio recibe una notificación especial, gracias a la cual puede realizar las acciones necesarias para la transición a un nuevo estado, por ejemplo, liberar recursos ocupados.

En segundo lugar, la capacidad de iniciar el servicio antes de registrar a un usuario y, como resultado, la capacidad de trabajar sin ningún usuario registrado. Cualquier servicio puede iniciarse automáticamente al inicio del sistema operativo y comenzar a funcionar incluso antes de que el usuario inicie sesión en el sistema.

Y finalmente, la capacidad de trabajar en un contexto de seguridad arbitrario. Contexto Seguridad de Windows NT define un conjunto de derechos de acceso a procesos para varios objetos y datos del sistema. A diferencia de una aplicación Win32 normal, que siempre se ejecuta bajo el contexto de seguridad del usuario que actualmente inició sesión en el sistema, el contexto de seguridad de ejecución de un servicio se puede predefinir. Esto significa que para un servicio es posible definir un conjunto de sus derechos de acceso a los objetos del sistema por adelantado y, por lo tanto, limitar el alcance de sus actividades. Para los servicios, existe un tipo especial de contexto de seguridad predeterminado denominado Sistema local. Un servicio que se ejecuta en este contexto tiene derechos solo sobre los recursos de la computadora local. No se pueden realizar operaciones de red con derechos de sistema local, ya que este contexto solo es significativo en computadora local y no es reconocido por otras computadoras en la red.

Interacción del servicio con otras aplicaciones

Cualquier aplicación que tenga los derechos apropiados puede interactuar con el servicio. La interacción, en primer lugar, implica un cambio en el estado del servicio, es decir, su transferencia a uno de tres estados: en ejecución (Inicio), suspendido (Pausa), detenido, y se lleva a cabo mediante el envío de solicitudes SCM. Las solicitudes son de tres tipos: mensajes de servicios (que corrigen sus estados), solicitudes relacionadas con cambiar la configuración de un servicio u obtener información sobre él, y solicitudes de aplicaciones para cambiar el estado de un servicio.

Para administrar un servicio, primero debe obtener su identificador mediante la función de la API Win32 OpenService. La función StartService inicia el servicio. Si es necesario, se cambia el estado del servicio llamando a la función ControlService.

Base de datos de servicios

La información sobre cada servicio se almacena en el registro, en la clave HKLM\SYSTEM\CurrentControlSet\Services\ServiceName. Contiene la siguiente información:

  • Tipo de servicio. Indica si esta aplicación implementa un solo servicio (exclusivo) o si hay varios servicios en la aplicación. Un servicio exclusivo puede ejecutarse en cualquier contexto de seguridad. Múltiples servicios dentro de la misma aplicación solo pueden ejecutarse en el contexto LocalSystem.
  • Tipo de lanzamiento. Automático: el servicio se inicia al iniciar el sistema. A pedido: el servicio lo inicia manualmente el usuario. Desactivado: no se puede iniciar el servicio.
  • El nombre del módulo ejecutable (archivo EXE).
  • Orden de inicio en relación con otros servicios. En algunos casos, el correcto funcionamiento de un servicio requiere que se ejecuten uno o más servicios. En este caso, el registro contiene información sobre los servicios iniciados antes de este.
  • Contexto de seguridad de ejecución del servicio ( nombre de red y contraseña). El contexto de seguridad predeterminado es LocalSystem.

Las aplicaciones que necesitan obtener información sobre un servicio en particular o cambiar una configuración particular de un servicio esencialmente necesitan cambiar la información en la base de datos del servicio en el registro. Esto se puede hacer a través de las funciones apropiadas de la API de Win32:

  • OpenSCManager, CreateService, OpenService, CloseServiceHandle: para crear (abrir) un servicio;
  • QueryServiceConfig, QueryServiceObjectSecurity, EnumDependentServices, EnumServicesStatus: para obtener información sobre el servicio;
  • ChangeServiceConfig, SetServiceObjectSecurity, LockServiceDatabase, UnlockServiceDatabase, QueryServiceLockStatus: para cambiar la información de configuración del servicio.

Internos de servicio.

Para que funcione, la aplicación debe organizarse de manera adecuada, es decir, debe incluir un determinado conjunto de funciones (en términos de C ++) con una determinada funcionalidad. Consideremos brevemente cada uno de ellos.

función principal

Como sabes, la función principal es el punto de entrada de cualquier aplicación de consola Win32. Cuando se inicia el servicio, el código de esta función comienza a ejecutarse primero. Dentro de los 30 segundos desde el inicio, la función principal debe necesariamente llamar a StartServiceCtrlDispatcher para establecer una conexión entre la aplicación y el SCM. Toda la comunicación entre cualquier servicio de esta aplicación y el SCM tiene lugar dentro de la función StartServiceCtrlDispatcher, que solo sale cuando todos los servicios de la aplicación se han detenido.

Servicio Función principal

Además del punto de entrada para todo el proceso, también hay un punto de entrada separado para cada uno de los servicios implementados en la aplicación. Los nombres de las funciones que son los puntos de entrada de los servicios (para simplificar, llamémoslos todos iguales - ServiceMain) se pasan al SCM en uno de los parámetros cuando se llama a StartServiceCtrlDispatcher. Cuando se inicia cada servicio, se crea un subproceso independiente para ejecutar ServiceMain.

Una vez que tiene el control, ServiceMain primero debe registrar un controlador de solicitud de servicio, una función de controlador, para cada uno de los servicios de la aplicación. Después de eso, a ServiceMain generalmente le sigue alguna acción para inicializar el servicio: asignación de memoria, lectura de datos, etc. Estas acciones deben ir acompañadas de notificaciones al SCM de que el servicio aún está en proceso de inicio y no se han producido fallas. Las notificaciones se envían mediante llamadas a la función SetServiceStatus. Todas las llamadas, excepto la más reciente, deben ser SERVICE_START_PENDING y la más reciente debe ser SERVICE_RUNNING. El desarrollador del servicio determina la frecuencia de las llamadas según la siguiente condición: la duración del intervalo de tiempo entre dos llamadas adyacentes a SetServiceStatus no debe exceder el valor del parámetro dwWaitHint pasado al SCM durante la primera de las dos llamadas. De lo contrario, el SCM detendrá el servicio a la fuerza si no recibe otra notificación a tiempo. Este método evita la situación del servicio al inicio como consecuencia de la aparición de determinados fallos (recordemos que los servicios suelen ser no interactivos y pueden iniciarse en ausencia de un usuario). La práctica habitual es que, después de completar el siguiente paso de inicialización, se notifique al SCM.

función de controlador

Como se mencionó anteriormente, Handler es el prototipo de una función de devolución de llamada, un controlador de solicitudes de servicio, específico para cada servicio en la aplicación. Se llama al controlador cuando el servicio recibe una solicitud (mensaje de inicio, pausa, reanudación, detención, estado actual) y realiza las acciones necesarias de acuerdo con la solicitud, después de lo cual informa el nuevo estado al SCM.

Se debe tener en cuenta una solicitud en particular: la solicitud que se produce al apagar el sistema (Apagar). Esta solicitud señala la necesidad de realizar la desinicialización y terminación. Microsoft afirma que cada servicio tiene 20 segundos para cerrarse, después de lo cual se ve obligado a detenerse. Sin embargo, las pruebas han demostrado que esta condición no siempre se cumple y el servicio se detiene por la fuerza antes de que expire este período de tiempo.

Sistema de seguridad de servicios

Cualquier acción sobre los servicios requiere que la aplicación tenga los derechos correspondientes. Todas las aplicaciones tienen derechos para conectarse al SCM, enumerar servicios y verificar si la base de datos del servicio está bloqueada. Solo las aplicaciones que tienen derechos administrativos pueden registrar un nuevo servicio en el sistema o bloquear la base de datos del servicio.

Cada servicio tiene un descriptor de seguridad que describe qué usuarios están autorizados para realizar qué operación. Por defecto:

  • Todos los usuarios tienen los derechos SERVICE_QUERY_CONFIG, SERVICE_QUERY_STATUS, SERVICE_ENUMERATE_DEPENDENTS, SERVICE_INTERROGATE y SERVICE_USER_DEFINED_CONTROL;
  • Los usuarios del grupo Usuarios avanzados y la cuenta LocalSystem tienen además los derechos SERVICE_START, SERVICE_PAUSE_CONTINUE y SERVICE_STOP;
  • Los usuarios de los grupos Administradores y Operadores del sistema tienen el derecho SERVICE_ALL_ACCESS.

Servicios e interactividad

De forma predeterminada, los servicios interactivos solo se pueden ejecutar en el contexto de seguridad de LocalSystem. Esto se debe a las peculiaridades de mostrar un monitor en Windows NT, donde, por ejemplo, existe un objeto como "Escritorio", para trabajar con el que debe tener los derechos de acceso apropiados, que pueden no estar disponibles para un arbitrario. cuenta, que no sea LocalSystem. A pesar de que en la gran mayoría de los casos esta restricción no es significativa, sin embargo, en ocasiones existe la necesidad de crear un servicio que muestre información en la pantalla del monitor y al mismo tiempo se ejecute en un contexto de seguridad diferente al LocalSystem, por ejemplo, un componente de servidor de aplicaciones para ejecutar aplicaciones en una computadora remota.

Fragmento de código de . ilustra esta posibilidad.

En este fragmento, en respuesta a una solicitud enviada por el lado del cliente de la aplicación como consecuencia de RPC, el servicio muestra un mensaje de texto en la pantalla del monitor.

Ejemplo de servicio (fragmentos de clave)

Veamos un ejemplo de los fragmentos clave de una aplicación C++ que implementa un servicio de Windows NT. Para mayor claridad, se omiten las partes no esenciales del código.

función principal

Se muestra el código de la función principal.

Servicio Función principal

Una característica del código contenido en ServiceMain es que a menudo es imposible predecir el tiempo de ejecución de una operación por adelantado, especialmente cuando se considera que su ejecución se lleva a cabo en un sistema operativo con multitarea preventiva. Si la operación dura más que el intervalo de tiempo especificado en el parámetro de llamada SetServiceStatus, el servicio no podrá enviar la siguiente notificación a tiempo, lo que hará que SCM detenga su operación. Ejemplos de operaciones potenciales son llamadas a funciones de red con grandes tiempos de espera o una lectura de una sola vez un número grande información de medios lentos. Además, este enfoque es completamente inaplicable al depurar un servicio, ya que la ejecución del programa en el depurador va acompañada de grandes pausas que son necesarias para el desarrollador.

Para superar este problema, todas las interacciones con el SCM deben realizarse en un subproceso separado, independientemente de las acciones que se produzcan durante la fase de inicialización.

B muestra un algoritmo para iniciar correctamente un servicio utilizando un subproceso auxiliar.

función de controlador

B muestra el código para la función Handler y los subprocesos auxiliares. Para las solicitudes de "Stop" y "Shutdown", se utiliza el algoritmo para detener correctamente el servicio, similar al que se usa al iniciar el servicio, con la única diferencia de que el parámetro SERVICE_STOP_PENDING se pasa a SetserviceStatus en lugar del parámetro SERVICE_START_PENDING, y SERVICE_STOPPED en lugar de SERVICIO_EN EJECUCIÓN.

Idealmente, las consultas "Pausar" y "Continuar" también deberían usar este enfoque. Un lector curioso puede implementarlo fácilmente basándose en estos ejemplos.

Conclusión

En conclusión, me gustaría señalar que con la transición a Windows NT 2000, el desarrollo de servicios no ha cambiado. Los servicios siguen siendo una parte importante del software en la plataforma Windows, lo que les da mucho trabajo a los desarrolladores.


// Función similar a MessageBox Win32 API int ServerMessageBox(RPC_BINDING_HANDLE h, LPSTR lpszText, LPSTR lpszTitle, UINT fuStyle) ( DWORD dwThreadId; HWINSTA hwinstaSave; HDESK hdeskSave; HWINSTA hwinstaUser; HDESK hdeskUser; int result; // Guardar la "estación de ventana" actual objetos " y "Desktop". GetDesktopWindow(); hwinstaSave = GetProcessWindowStation(); dwThreadId = GetCurrentThreadId(); hdeskSave = GetThreadDesktop(dwThreadId); // Cambie el contexto de seguridad al // que tiene el cliente RPC que llama // y obtener acceso al usuario // objetos "Estación de ventana" y "Escritorio". RpcImpersonateClient(h); hwinstaUser = OpenWindowStation("WinSta0", FALSE, MAXIMUM_ALLOWED); if (hwinstaUser == NULL) ( RpcRevertToSelf(); return 0; ) SetProcessWindowStation( hwinstaUser); hdeskUser = OpenDesktop("Default", 0, FALSE, MAXIMUM_ALLOWED); RpcRevertToSelf(); if (hdeskUser == NULL) ( SetProcessWindowStation(hwinstaSave); CloseWindowStation(hwinstaUser); ret urna0; ) SetThreadDesktop(hdeskUser); // Mostrar un cuadro de texto normal. resultado = MessageBox(NULL, lpszText, lpszTitle, fuStyle); // Restaurar objetos guardados // "Estación de ventana" y "Escritorio". SetThreadDesktop(hdeskSave); Establecer estación de ventana de proceso (hwinstaSave); CloseDesktop(hdeskUser); CerrarEstaciónDeVentana(usuariohwinsta); resultado devuelto; ) void main() ( SERVICE_TABLE_ENTRY steTable = ( (SERVICENAME, ServiceMain), (NULL, NULL) ); // Establecer una conexión con el SCM. Dentro de esta función // se reciben y envían solicitudes. StartServiceCtrlDispatcher(steTable); ) void WINAPI ServiceMain (DWORD dwArgc, LPSTR *psArgv) ( // Registre inmediatamente el controlador de solicitudes. hSS = RegisterServiceCtrlHandler(SERVICENAME, ServiceHandler); sStatus.dwCheckPoint = 0; sStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE; sStatSERVus.dwServiceSpecificExitCode = 0.; sStatSERVus dwServiceSpecificExitCode = 0; sStatus.dwServiceSpecificExitCode = 0; sStatus.dwServiceSpecificExitCode = 0; ; sStatus.dwWaitHint = 0; sStatus.dwWin32ExitCode = NOERROR; // Para inicializar el servicio, se llama a la función InitService(); // Para garantizar que el sistema no // descarga el servicio durante el proceso de inicialización, se inicia un subproceso que informa una vez cada // segundo que el servicio está en proceso de inicialización. // Se crea un evento para sincronizar el subproceso. // Después de eso, el subproceso de trabajo se inicia, para Para sincronizar qué // también se crea un evento. hSendStartPending = CreateEvent(NULO, VERDADERO, FALSO, NULO); HANDLE hSendStartThread; DWORD dwThreadId; hSendStartThread = CreateThread(NULL, 0, SendStartPending, NULL, 0, &dwThreadId); //Toda la inicialización del servicio se realiza aquí. InitService(); SetEvent(hSendStartPending); if(WaitForSingleObject(hSendStartThread, 2000) != WAIT_OBJECT_0) ( TerminateThread(hSendStartThread, 0); ) CloseHandle(hSendStartPending); CloseHandle(hSendStartThread); hWork = CreateEvent(NULO, VERDADERO, FALSO, NULO); hServiceThread = CreateThread(NULL, 0, ServiceFunc, 0, 0, &dwThreadId); sStatus.dwCurrentState = SERVICIO_EN EJECUCIÓN; EstablecerEstadoServicio(hSS, &sEstado); ) // Una función de subproceso que envía notificaciones al SCM cada segundo // de que el proceso de inicialización está en curso. La función finaliza // cuando se establece el evento hSendStartPending //. DWORD WINAPI SendStartPending(LPVOID) ( sStatus.dwCheckPoint = 0; sStatus.dwCurrentState = SERVICE_START_PENDING; sStatus.dwWaitHint = 2000; // "Dormir" durante 1 segundo. Si después de 1 segundo // el evento hSendStartPending no // ha pasado a la estado señalado ( // la inicialización del servicio no ha finalizado), enviamos otra notificación, // estableciendo el intervalo de tiempo máximo // en 2 segundos, para tener un margen de tiempo antes // de la próxima notificación. while (true) ( ​SetServiceStatus(hSS, &sStatus); sStatus .dwCheckPoint++;if(WaitForSingleObject(hSendStartPending, 1000)!=WAIT_TIMEOUT) break; ) sStatus.dwCheckPoint = 0; return 0; ) // Función que inicializa el servicio. Lectura de datos, // asignación de memoria, etc. void InitService() ( ... ) // Función que contiene el código de servicio. DWORD WINAPI ServiceFunc(LPVOID) ( while (true) ( ​​if (!bPause) ( // Esto contiene código que típicamente // realiza algún tipo de operación cíclica... ) if (WaitForSingleObject(hWork, 1000)!=WAIT_TIMEOUT ) break; ) return 0; ) // Controlador de solicitudes de SCM void WINAPI ServiceHandler(DWORD dwCode) ( switch (dwCode) ( case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0, 1000); hSendStopPending = CreateEvent(NULL, VERDADERO, FALSO, NULL); hSendStopThread = CreateThread(NULL, 0, SendStopPending, NULL, 0, & dwThreadId); SetEvent(hWork); if (WaitForSingleObject(hServiceThread, 1000) != WAIT_OBJECT_0) ( TerminateThread(hServiceThread, 0); ) SetEvent(hSendStopPending); CloseHandle(hServiceThread); CloseHandle(hWork); if(WaitForSingleObject(hSendStopThread, 2000) != WAIT_OBJECT_0) ( TerminateThread(hSendStopThread, 0); ) CloseHandle(hSendStopPending); sStatus.dwCurrentState = SERVICIO_DETENIDO; EstadoServicio(hSS, &sEstado); descanso; case SERVICE_CONTROL_PAUSE: bPausa = verdadero; sStatus.dwCurrentState = SERVICIO_PAUSADO; EstablecerEstadoServicio(hSS, &sEstado); descanso; case SERVICE_CONTROL_CONTINUE: bPausa = verdadero; sStatus.dwCurrentState = SERVICIO_EN EJECUCIÓN; EstablecerEstadoServicio(hSS, &sEstado); descanso; caso SERVICE_CONTROL_INTERROGATE: SetServiceStatus(hSS, &sStatus); descanso; predeterminado: SetServiceStatus(hSS, &sStatus); descanso; ) ) // Función de hilo similar a SendStartPending // para detener el servicio. DWORD WINAPI SendStopPending(LPVOID) ( sStatus.dwCheckPoint = 0; sStatus.dwCurrentState = SERVICE_STOP_PENDING; sStatus.dwWaitHint = 2000; while (true) ( ​​​​SetServiceStatus(hSS, &sStatus); sStatus.dwCheckPoint++; if(WaitForSingleObject(hSendStopPending0), ! =WAIT_TIMEOUT) break; ) sStatus.dwCheckPoint = 0; return 0; )

Cómo ejecutar una aplicación como un servicio de Windows

¿Es posible ejecutar una aplicación cliente como un servicio? En uno de ellos, describí cómo crear un servicio de Windows utilizando las herramientas habituales del sistema operativo. Sin embargo, no todas las aplicaciones de consola podrán ejecutarse como un servicio, y los programas con una interfaz gráfica, en principio, no pueden funcionar de esta manera. Pero todavía existe la oportunidad de ejecutar la aplicación como un servicio, y el programa con el nombre original nos ayudará con esto. Gerente de servicio no succionador.

NSSM es gratis software Con fuente abierta y es compatible con todos los sistemas operativos de Microsoft, desde Windows 2000 hasta Windows 8. NSSM no requiere instalación, solo descárguelo y descomprímalo. El kit de distribución incluye versiones para sistemas operativos de 32 y 64 bits. Puede obtener el programa del sitio nssm.cc, por el momento la última versión estable es la 2.21.1, la cual usaré.

Para demostrar las capacidades de NSSM, intentemos ejecutar Bloc de notas de Windows como un servicio en Windows 8.1.

crear un servicio

Para crear un servicio llamado bloc inicie la consola de comandos, vaya a la carpeta con el NSSM desempaquetado (para Windows de 64 bits) e ingrese el comando nssm install notepad , que abre la ventana del instalador gráfico de NSSM. Para crear un servicio, basta con especificar la ruta al archivo ejecutable en el campo Ruta y hacer clic en el botón "Instalar servicio". Además, en el campo Opciones, puede especificar las claves necesarias para iniciar el servicio.

Además, en la etapa de creación de un nuevo servicio, puede especificar algunos parámetros adicionales.

La pestaña Apagar enumera los métodos de apagado y los tiempos de espera utilizados durante el apagado normal o el apagado de emergencia de la aplicación. Cuando NSSM recibe un comando de detención (por ejemplo, cuando finaliza una aplicación), intenta detener la aplicación controlada de la forma habitual. Si la aplicación no responde, NSSM puede terminar por la fuerza todos los procesos y subprocesos de esta aplicación.

Hay cuatro pasos de cierre de aplicaciones en total y, de forma predeterminada, se utilizarán en este orden:

En el primer paso, NSSM intenta generar y enviar un evento ctrl+c. Este método funciona bien para aplicaciones de consola o scripts, pero no para aplicaciones gráficas;
NSSM luego detecta todas las ventanas creadas por la aplicación y les envía un mensaje WM_CLOSE para forzar la salida de la aplicación;
En el tercer paso, NSSM evalúa todos los subprocesos creados por la aplicación y les envía un mensaje WM_QUIT, que se recibirá si la aplicación tiene una cola de mensajes de subprocesos;
Y como último recurso, NSSM puede llamar al método TerminateProcess(), terminando la aplicación a la fuerza.

Sin embargo, es posible deshabilitar algunos o incluso todos los métodos para diferentes aplicaciones funcionan diferentes métodos, y para el cierre correcto de la aplicación, se recomienda dejar todo como está.

De forma predeterminada, cuando un servicio falla, NSSM intenta reiniciarlo. En la pestaña "Acciones de salida", puede cambiar la acción automática en caso de un cierre anormal de la aplicación, así como establecer un retraso antes de que la aplicación se reinicie automáticamente.

En la pestaña "Entrada / Salida (E / S)", puede configurar la redirección de la entrada / salida de la aplicación al archivo especificado.

En la pestaña "Entorno", puede establecer nuevas variables de entorno para el servicio o anular las existentes.

Tampoco puede usar el shell gráfico e inmediatamente crear un servicio en la consola con el siguiente comando:

nssm instalar el bloc de notas ″C:\Windows\system32\notepad.exe″

Gestión De Servicios

Después de crear el servicio mediante NSSM, vaya al complemento Servicios y busque el servicio de bloc de notas. Como puedes ver, en apariencia no se diferencia de otros servicios, también podemos iniciarlo, detenerlo o cambiar el modo de inicio. Tenga en cuenta, sin embargo, que nssm.exe aparece como ejecutable.

Y si va al Administrador de tareas, veremos la siguiente imagen: NSSM se está ejecutando como el proceso principal (principal), el servicio de bloc de notas se está ejecutando como su proceso secundario y la aplicación Bloc de notas ya se está ejecutando en este proceso secundario.

Eliminación de un servicio

Para eliminar el servicio, ingrese el comando nssm remove notepad y confirme su eliminación. Y al escribir nssm remove notepad confirm , puede prescindir de la confirmación.

Inicio de un servicio de forma interactiva

Diferencia principal aplicación personalizada del servicio es que después del lanzamiento, la aplicación puede requerir acciones adicionales por parte del usuario para continuar trabajando, por ejemplo, hacer clic en un botón o ingresar un comando. Para hacer esto, debe obtener acceso a él, lo que resulta que no es tan fácil de hacer.

Para iniciar el servicio en modo interactivo, debe abrir sus propiedades en el complemento Servicios y en la pestaña "Iniciar sesión", marque la casilla de verificación "Permitir interacción con el escritorio".

Y luego comienzan los milagros 🙂 Un servicio lanzado en modo interactivo se abre en una sesión aislada (sesión 0). A esta sesión solo puede acceder el Servicio de detección de servicios interactivos (ui0detect), que supervisa el inicio de los servicios interactivos en la computadora y emite una alerta. En Windows 7\Server 2008 este servicio está habilitado de manera predeterminada, pero en Windows 8\Server 2012 está deshabilitado y no aparece en el complemento gráfico de Servicios (al menos yo no lo encontré allí). Además, si encuentra este misterioso servicio e intenta iniciarlo, recibirá un mensaje de error.

Pero el hecho es que para ejecutarlo, debe permitir el lanzamiento de servicios interactivos en la computadora. Por lo tanto, abrimos el editor de registro, encontramos en la sección HKLM\System\CurrentControlSet\Control\Windows un parámetro DWORD con el nombre Sin servicios interactivos y establecer su valor en 0 .

Luego abrimos la consola de PowerShell e iniciamos el servicio de descubrimiento con el comando:

Servicio de inicio -Nombre ui0detect

Después de asegurarnos de que el servicio de descubrimiento se está ejecutando, reiniciamos el servicio del bloc de notas y aparece esta ventana. Seleccione "Ver mensaje"

y entrar en la sesión cero en la que se está ejecutando nuestra aplicación. Luego realizamos las acciones necesarias con él y regresamos.

Una solución tan interesante para ejecutar aplicaciones como servicios de Windows. No es el más bonito, pero bastante fiel a su nombre 🙂

Última actualización: 31.10.2015

Los servicios son uno de los componentes más importantes del sistema operativo Windows. De hecho, se trata de aplicaciones independientes que no cuentan con una interfaz gráfica y que realizan varias tareas en segundo plano. Los servicios se pueden iniciar al inicio del sistema operativo o en cualquier otro momento durante el trabajo del usuario. Un ejemplo común de servicios son varios servidores web que escuchan en segundo plano en un puerto específico las conexiones y, si hay conexiones, interactúan con ellas. También pueden ser varios servicios auxiliares de actualización para otros programas instalados que contacta con el servidor para ver si hay una nueva version aplicaciones En general, podemos abrir el panel de servicios y ver por nosotros mismos todos los servicios instalados y en ejecución:

Veamos cómo crear sus propios servicios en C#. Como tarea a implementar, optaremos por monitorear los cambios en una carpeta específica del sistema de archivos. Ahora vamos a crear un servicio para ejecutarlo.

Primero, creemos un nuevo proyecto, que será del tipo Servicio de Windows. Llamemos al proyecto FileWatcherService:

Después de eso, Visual Studio genera un proyecto que tiene todo lo que necesitas. Aunque en principio no tenemos que elegir este tipo de proyecto en particular, podríamos crear un proyecto de biblioteca de clases y luego definir todas las clases requeridas en él.

Así que el nuevo proyecto se ve así:

También hay un archivo Program.cs y está el propio nodo de servicio Service1.cs.

El servicio representa una aplicación normal, pero no se inicia solo. Todas las llamadas y el acceso a él pasan por el Administrador de control de servicios (SCM). Cuando el servicio se inicia automáticamente al iniciar el sistema o manualmente, el SCM llama al método Main en la clase Program:

Programa de clase estática ( static void Main() ( ServiceBase ServicesToRun; ServicesToRun = new ServiceBase ( new Service1() ); ServiceBase.Run(ServicesToRun); ) )

El método Main está definido de forma predeterminada para ejecutar varios servicios a la vez, que están definidos en la matriz ServicesToRun. Sin embargo, de forma predeterminada, el proyecto contiene solo un servicio, Service1. El lanzamiento en sí se realiza mediante el método Run: ServiceBase.Run(ServicesToRun) .

El propio servicio que se va a iniciar está representado por el nodo Service1.cs. Sin embargo, este no es realmente un archivo de código simple. Si abrimos este nodo, veremos el archivo del diseñador de servicios Service1.Designer.cs y la clase Service1 en él.

La clase Service1 en realidad representa el servicio. Por defecto tiene el siguiente código:

Sistema de uso; usando System.Collections.Generic; utilizando System.ComponentModel; utilizando System.Data; utilizando System.Diagnostics; utilizando System.Linq; utilizando System.ServiceProcess; usando Sistema.Texto; utilizando System.Threading.Tasks; espacio de nombres FileWatcherService ( clase parcial pública Service1: ServiceBase ( public Service1() ( InitializeComponent(); ) protected override void OnStart(string args) ( ) protected override void OnStop() ( ) ) )

La clase de servicio debe heredar de la clase base ServiceBase. Esta clase define una serie de métodos, los más importantes son el método OnStart(), que inicia las acciones realizadas por el servicio, y el método OnStop(), que detiene el servicio.

Después de que SCM llama al método Main y registra el servicio, se llama directamente ejecutando el método OnStart.

Cuando en la consola de servicios o a través de línea de comando enviamos un comando para detener el servicio, luego el SCM llama al método OnStop para detenerlo.

Además de estos dos métodos en la clase de servicio, puede anular varios métodos más de la clase base ServiceBase:

    OnPause: llamado cuando el servicio está en pausa

    OnContinue : Llamado cuando el servicio se reanuda después de haber sido suspendido

    OnShutdown: Llamado cuando Windows se apaga

    OnPowerEvent: llamado cuando cambia el modo de energía

    OnCustomCommand: se llama cuando el servicio recibe un comando personalizado del Administrador de control de servicios (SCM)

El constructor de la clase Service1 llama al método InitializeComponent(), que se define en el archivo del diseñador Service1.Designer.cs:

Namespace FileWatcherService ( clase parcial Service1 ( private System.ComponentModel.IContainer components = null; protected override void Dispose(bool disposing) ( if (disposing && (components != null)) ( components.Dispose(); ) base.Dispose(disposing ); ) private void InitializeComponent() (componentes = new System.ComponentModel.Container(); this.ServiceName = "Service1"; ) ) )

Lo único a tener en cuenta es establecer el nombre del servicio (propiedad ServiceName):

Este.ServiceName = "Servicio1";

Este es el nombre que se mostrará en la consola de servicios después de instalar el servicio. Podemos cambiarlo, o podemos dejarlo como está.

Ahora cambiemos el código de servicio de la siguiente manera:

Sistema de uso; utilizando System.ServiceProcess; utilizando System.IO; utilizando System.Threading; espacio de nombres FileWatcherService ( clase parcial pública Service1: ServiceBase ( Logger logger; public Service1() ( InitializeComponent(); this.CanStop = true; this.CanPauseAndContinue = true; this.AutoLog = true; ) protected override void OnStart(string args) ( logger = new Logger(); Thread loggerThread = new Thread(new ThreadStart(logger.Start)); loggerThread.Start(); ) protected override void OnStop() ( logger.Stop(); Thread.Sleep(1000); ) ) class Logger (FileSystemWatcher watcher; object obj = new object(); bool enable = true; public Logger() ( watcher = new FileSystemWatcher("D:\\Temp"); watcher.Deleted += Watcher_Deleted; watcher.Created + = Watcher_Created; watcher.Changed += Watcher_Changed; watcher.Renamed += Watcher_Renamed; ) public void Start() ( watcher.EnableRaisingEvents = true; while(enabled) ( Thread.Sleep(1000); ) ) public void Stop() ( watcher.EnableRaisingEvents = false; enable = false; ) // renombrar archivos privados e void Watcher_Renamed(object sender, RenamedEventArgs e) (string fileEvent = "renamed to" + e.FullPath; string filePath = e.OldFullPath; RecordEntry(fileEvent, filePath); ) // cambiar archivos private void Watcher_Changed(object sender, FileSystemEventArgs e) ( string fileEvent = "changed"; string filePath = e.FullPath; RecordEntry(fileEvent, filePath); ) // crear archivos private void Watcher_Created(object sender, FileSystemEventArgs e) ( string fileEvent = "creado"; string filePath = e.FullPath; RecordEntry(fileEvent, filePath); ) // elimina archivos private void Watcher_Deleted(object sender, FileSystemEventArgs e) ( string fileEvent = "deleted"; string filePath = e.FullPath; RecordEntry(fileEvent, filePath); ) private void RecordEntry(string fileEvent, string filePath) ( lock (obj) ( using (StreamWriter escritor = new StreamWriter("D:\\templog.txt", true)) ( escritor.WriteLine(String.Format("(0) file(1) was(2)", DateTime.Now.ToString("dd/MM/yyyy hh:mm:ss"), filePath, fileEvent)); Flush(); ) ) ) ) )

La clase clave que encapsula toda la funcionalidad es la clase Logger. Usando el objeto FileSystemWatcher, monitoreará los cambios en la carpeta D://Temporal. El método Start() especifica que observaremos los cambios a través del objeto FileSystemWatcher. Y todo el trabajo funcionará siempre que la variable booleana habilitada sea verdadera. Y el método Stop() le permitirá terminar la clase.

Los eventos de FileSystemWatcher le permiten monitorear todos los cambios en la carpeta observada. Esto registrará los cambios en el archivo templog.txt. Para evitar una carrera de recursos para el archivo templog.txt en el que se escriben los cambios, el código auxiliar lock(obj) bloquea el procedimiento de escritura.

Como resultado, después de crear, modificar, renombrar y eliminar, el archivo de registro contendrá algo como:

El 30/07/2015 a las 12:15:40 p. m. se creó el archivo D:\Temp\New Text Document.txt el 30/07/2015 a las 12:15:46 p. fue renombrado a D:\Temp\hello.txt 07/30/2015 12:15:55 PM archivo D:\Temp\hello.txt fue modificado 07/30/2015 12:15:55 PM archivo D:\Temp\ hello.txt fue modificado 07/30/2015 12:16:01 PM archivo D: \Temp\hello.txt ha sido eliminado

En la propia clase de servicio Service1, se establecen una serie de opciones en el constructor:

Esto.PuedeDetener = verdadero; // el servicio se puede detener this.CanPauseAndContinue = true; // el servicio se puede pausar y luego reanudar this.AutoLog = true; // el servicio puede escribir en el registro

En el método OnStart(), se llama a un nuevo subproceso para iniciar el objeto Logger:

Anulación protegida void OnStart(string args) ( logger = new Logger(); Thread loggerThread = new Thread(new ThreadStart(logger.Start)); loggerThread.Start(); )

El subproceso nuevo es necesario porque el subproceso actual solo procesa comandos SCM y debe regresar del método OnStart lo más rápido posible.

Cuando se recibe un comando del SCM para detener el servicio, se activa el método OnStop, que llama al método logger.Stop(). El retraso adicional permitirá que el hilo del registrador se detenga:

Anulación protegida void OnStop() ( logger.Stop(); Thread.Sleep(1000); )

Sin embargo, la clase de servicio en sí misma no es suficiente. También necesitamos crear un instalador de servicios.

O el escritorio de los usuarios (tanto locales como remotos), sin embargo, para algunos servicios, es posible una excepción: interacción con la consola (número de sesión 0, en el que el usuario inicia sesión localmente o cuando se inicia el servicio mstsc con la tecla /consola).

Hay varios modos para los servicios:

  • prohibido lanzar;
  • arranque manual (bajo pedido);
  • inicio automático cuando la computadora arranca;
  • inicio automático (retrasado) (introducido en Windows Vista y Windows Server 2008);
  • servicio/controlador requerido (arranque automático e incapacidad (para el usuario) de detener el servicio).

modo de fondo

Iniciar, detener y cambiar los servicios de Windows

Los servicios y sus atributos se pueden cambiar en MMC:

Las diferentes versiones de los sistemas operativos pueden tener algunos servicios y otros no. Algunas aplicaciones y programas instalados por separado también pueden crear sus propios servicios.

Lista de servicios del sistema operativo Microsoft Windows

Nombre para mostrar Nombre del Servicio Funciones Descripción
cliente DHCP dhcp Registra y actualiza las direcciones IP y los registros DNS para esta computadora. Si se detiene este servicio, esta computadora no podrá obtener direcciones IP dinámicas ni realizar actualizaciones de DNS.
cliente DNS dnscaché El servicio de cliente DNS (dnscache) almacena en caché los nombres del Sistema de nombres de dominio (DNS) y registra el nombre completo de esta computadora. Si se detiene el servicio, la resolución de nombres DNS continuará. Sin embargo, los resultados de las colas de nombres DNS no se almacenarán en caché y el nombre de la computadora no se registrará.
KtmRm para coordinador de transacciones distribuidas KtmRm Coordina las transacciones entre MSDTC y Kernel Transaction Manager (KTM).
ListoBoost EMDMgmt ListoBoost Soporte para mejorar el rendimiento del sistema con la tecnología ReadyBoost.
Superfetch Sistema principal Superfetch Mantiene y mejora el rendimiento del sistema.
Sonido de Windows Audiosrv Gestión de herramientas de audio para programas de Windows. Si se detiene este servicio, los dispositivos y efectos de audio no funcionarán correctamente.
Espacio de tarjeta de Windows idsvc Proporciona una forma segura de crear, administrar y exponer identidades digitales.
Actualización automática WUAUSERV Incluye la descarga e instalación de actualizaciones de Windows. Si el servicio está deshabilitado, esta computadora no podrá usar las actualizaciones automáticas o el sitio web de Windows Update.
Llamada a procedimiento remoto (RPC) RpcSs Proporciona mapeo entre puntos finales y otros servicios RPC.

Lista de servicios creados por aplicaciones y programas de Microsoft

Ejemplos de servicios creados por aplicaciones y programas de terceros

Nombre para mostrar Nombre del Servicio Funciones Descripción
Servidor HTTP de ESET EhttpSrv protección antivirus Componente del servidor HTTP de ESET


ARTÍCULOS RELACIONADOS