Windows Server : Scripting

Administrar registros de rendimiento: Relog

juansa — Wed, 08 Jul 2009 09:01:38 GMT

Unión de registros de contador con Relog

Podemos utilizar Relog para unir datos de múltiples registros de rendimiento en un único archivo. Se especifica la ruta y los nombres de archivos de los diversos registros de rendimiento como parte del parámetro inicial:

relog c:\registros\registro1.blg c:\registros\registro2.blg c:\registros\registro3.blg –o c:\misRegistros\RegistroDestino.blg –a

Usamos el parámetro –a para indicarle a Relog que debe añadir la salida de cualesquiera datos al archivo de salida cuando se unen datos de múltiples registros.

Los registros almacenados en equipos remotos también pueden unirse mediante el uso de la ruta UNC en lugar de la ruta local.

relog \\servidor01\registros\reg1.blg \\servidor02\registros\reg2.blg \\servidor03\registros\reg3.blg –o c\misRegistros\RegDestino.blg –a –f blg

Las rutas individuales no deben superar los 1024 caracteres.

Formato del archivo de salida de Relog

Relog es compatible con los mismos formatos de archivos de entrada y salida como Logman a excepción del binario circular y de establecer tamaños límite de archivo. Si se crea un nuevo archivo de salida éste tendrá el formato binario de forma predeterminada. Relog sólo puede añadir datos sobre archivos existentes, y los archivos de entrada y salida están en formato binario.

Cuando creamos un nuevo archivo de salida podemos usar el parámetro –f para especificar uno de los formatos: bin (formato binario, predeterminado), csv (valores separados por comas), tsv (Valores separados por tabulación) o SQL (formato SQL).

Filtrar archivos de registro con Relog

Relog tiene capacidad de filtrado, que puede usarse para la extracción de datos de rendimiento desde un registro de contador de entrada basado en los siguientes criterios:

Una lista de contadores, especificados con sus rutas.
Un rango especificado de fecha y hora.

Sólo los contadores que cumplan los criterios especificados se escribirán en el archivo de salida que Reglog cree.

Filtrado por contador Se basa en una lista de contadores, especificados en la la línea de comandos o en un archivo de configuración. Relog grabará en el archivo designado de salida sólo aquéllos valores de los contadores especificados.

relog c:\registros\reg01.txt –o c:\registros\nuevoreg.txt –f csv –c "\Memory\Available Bytes"

Para la extracción de datos de más de un contador, se incluye cara ruta del contador como parte del parámetro –c.

relog c:\registros\reg01.txt –o c:\registros\nuevoreg.txt –f csv –c "\Memory\Available Bytes" "\Memory\Pages/sec" "\Memory\Cache Bytes"

Nota: Relog no realiza monitorización por sí mismo; todo lo que hace es recoger datos desde registros de rendimiento existentes. Si especificamos un contador que no se encuentra en ninguno de los archivos de entrada, el contador no aparecerá en el archivo de salida.

Si nuestro registro de entrada contiene datos de múltiples equipos, se incluye el nombre del equipo como parte de la ruta del contador.

relog c:\registros\reg01.txt –o c:\registros\nuevoreg.txt –f csv –c "\\EQUIPO\Memory\Available Bytes"

En lugar de escribir una gran cantidad de contadores de rendimiento como parte del comando, podemos usar un archivo de configuración, un simple archivo de texto conteniendo las rutas de cada contador en una fila.

Para filtrar los archivos de entrada que sólo tengan aquéllos contadores que estén en el de salida, usar el parámetro –cf seguido de la ruta del archivo de configuración.

Filtrado por fecha Relog proporciona la habilidad de extraer subconjuntos de datos basados en fecha y hora. Para ello se especifica la hora de comienzo (parámetro –b) y la hora final (parámetro –e) como parte de nuestro comando. Tanto uno como otro parámetros expresan fechas y horas usando el formado mm-dd-yyyy hh:mm:ss, més día año, hora, minuto y segundos, la hora se expresa en formato 24 horas.

relog c:\registros\reg01.txt –f csv –o c:\registros\Nuevoreg.txt –b 07-07-2009 09:30:00 –e 07-08-2009 11:00:00

Si sólo indicamos las horas, se asume la fecha del día actual.

relog c:\registros\reg01.txt –o c:\registros\Nuevoreg.txt –b 09:30:00 –e 11:00:00

Siguiendo con Logman

juansa — Wed, 01 Jul 2009 10:06:34 GMT

Con Logman podemos programar opciones que nos permitan la programación de la recogida de datos en horas específicas durante el día. Mediante intervalos de muestra diferentes podemos tener también a Logman recogiendo datos en intervalos regulares. Lo que no podemos hacer es programar la recogida de datos de en horarios irregulares. Por ejemplo: los 10 primeros minutos de cada hora.

Podemos con Typeperf hacerlo. Creamos un archivo de lotes que configure Typeperf para tomar muestras sólo 10 minutos y luego programamos que el archivo de lotes se ejecute una vez cada hora con el Administrador de tareas.

Sin embargo, ya que Logman es scriptable, podemos combinar WSH y Logman para programar la recogida de datos usando intervalos irregulares. Un script:

        1: Set WshShell = WScript.CreateObject("WScript.Shell")

       2: Do

       3:     WshShell.Run "%COMPSEC% /c logman -start dns_log"

       4:     Script.Sleep 300000

       5:     WshShell.Run "%COMPSEC% /c logman -stop dns_log"

       6:     WScript.Sleep 3300000

       7: Loop

Inicia Logman y se para por cinco minutos, tiempo que Logman recoge datos, luego lo detiene y permanece 55 minutos inactiva hasta volver a activar el Ciclo(Loop).

       1: Set WshShell = WScript.CreateObjetc("WScript.Shell")

       2: For i = 1 to 24

       3:     WshShell.Run "%COMPSEC /c logman -start dns_log"

       4:     WScript.Sleep 300000

       5:     WshShell.Run "%COMPSEC /c logman -stop dns_log"

       6:     WScript.Sleep 3300000

       7: Next i

       8: WScript.Quit

Este hace lo mismo pero se ejecuta 24 veces, una vez cada hora.

Queremos el resultado de un script por email

juansa — Wed, 03 Dec 2008 15:57:35 GMT

Bien, pues aquí tenemos un script que podemos lanzar para que nos informe del estado de los servicios por email diariamente.

   1: 'Este script sirve para comprobar cambios de estado de los servicios   2: ' usando event log y enviar después un aviso por email   3:     4: '(c) Juansa 03-12-2008   5: 'leer el archivo   6: Function leearchivo (nombreArchivo)   7:     Const ForReading = 1, ForWriting = 2   8:        Dim fso, f   9:        Set fso = CreateObject("Scripting.FileSystemObject")  10:     Set f = fso.OpenTextFile(nombreArchivo, ForReading)  11:     leearchivo = f.ReadAll  12: End Function  13: 'existe el archivo  14: Function Existe(archivo)  15:    Dim fso  16:    Set fso = CreateObject("Scripting.FileSystemObject")  17:    If (fso.FileExists(archivo)) Then   18:     Existe = True  19:    Else  20:       Existe = False  21:    End If  22:      23: End Function  24: 'cuerpo script  25: 'Creamos constantes y variables  26: Const ForReading = 1, ForWriting = 2  27: Dim TabStop, NewLine, filename, strDate, dia, mes, ano  28: TabStop = Chr(9)  29: NewLine = Chr(10)  30: dia = left(Date, 2)  31: ano = right(Date, 4)  32: mes = mid(Date, 4,2)  33: strDate = dia & "-" & mes & "-" & ano  34: filename = "c:\scripts\InformeServicios_" & strDate & ".txt"  35:    36: 'comprobaremos que el informe no exista ya  37: if Existe(filename) = true then  38: 'no se ejecutará nada  39: else  40: Dim fso, miarchivo  41: Set fso = CreateObject("Scripting.FileSystemObject")  42: set miarchivo = fso.CreateTextFile(filename, True)  43: miarchivo.close  44: Set objFSO = CreateObject("Scripting.FileSystemObject")  45: Set objFile = objFSO.OpenTextFile(filename, ForWriting, True)  46:    47: Set dtmConvertedDate = CreateObject("wbemScripting.SwbemDateTime")  48:    49: StrComputer = "."  50: Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=Impersonate}!\\" & strComputer &  "\root\cimv2")  51:    52: Set ColServiceEvents = objWMIService.ExecQuery ("SELECT * FROM Win32_NTLogEvent WHERE LogFile =  'System' AND " & "EventCode = '7036'")  53:    54: For Each strEvent in ColServiceEvents  55:     dtmConvertedDate.Value = strEvent.TimeWritten  56:     objFile.WriteLine dtmConvertedDate.GetVarDate  57:     objFile.WriteLine strEvent.Message  58: Next  59:    60:    61: 'el archivo se ha creado ya  62: 'vamos a enviar el email  63: 'OJO CON LOS DATOS A RELLENAR  64: esquema = "http://schemas.microsoft.com/cdo/configuration/"  65: Set cdoConfig = CreateObject("CDO.Configuration")  66:     With cdoConfig.Fields   67:         .Item(esquema & "sendusing") = 2   68:         .Item(esquema & "smtpserver") = "tuservidorSMTP"   69:         .Item(esquema & "smtpauthenticate") = 1   70:         .Item(esquema & "sendusername") = "TuUsuario"  71:         .Item(esquema & "sendpassword") = "Tuclave"  72:         .Item(esquema & "smtpserverport") = 25 'si se usa otro  73:         .Item(esquema & "smtpusessl") = False 'si se usa ssl True  74:         .Item(esquema & "smtpconnectiontimeout") = 60  75:         .update  76:     End With  77: Set cdoMessage = CreateObject("CDO.Message")  78:     With cdoMessage  79:         Set .Configuration = cdoConfig  80:         .From = "tucuenta@tudominio"  81:         .To = "tucuenta@tudominio"  82:         .Subject = "prueba de envío"  83:         .TextBody = "El equipo ha tenido un error, revisa el registro"  84:         .Send  85:     End With  86: Set cdoMessage = Nothing  87: Set cdoConfig = Nothing  88: end if  89: ' wscript.Echo "FINAL"

Cualquier otro script puede montarse de la misma manera, así como asignar el envío de un correo a un eventtrigger por ejemplo.

Monitorizar los Servicios, y 4

juansa — Mon, 01 Dec 2008 10:18:14 GMT

Monitorizar el rendimiento del servicio

Hemos monitorizado los servicios en cuanto a su disponibilidad y su fiabilidad, pero nos falta algo, ¿podemos llevar a cabo alguna monitorización que nos ayude a impedir los fallos?.

Una estrategia de monitorización que nos ayude a hacer lo siguiente:

Determinar porqué se ha detenido el servicio. ¿Se queda sin memoria?, ¿Demasiados usuarios accediendo? ¿Algún cuello de botella en los discos o la red?
Predecir los fallos con antelación. Con ciertos servicios puede que seamos capaces de predecir su fallo si el servicio excede de un umbral específico. Aquí podemos servirnos de un script que monitorice las operaciones por segundo que realiza el servicio. Cuando el valor se aproxime al umbral específico, el script puede o limitar el número de conexiones simultáneas o encaminar a los usuarios hacia otros servicios iguales en otros equipos.

¿Cómo podríamos monitorizar el rendimiento?

Monitorizar el proceso del servicio. Cada servicio tiene un proceso responsable del mismo. Si lo monitorizamos podemos asegurarnos que utiliza la memoria y otros recursos adecuadamente. Sin embargo no podemos saber si el servicio está llevando a cabo su función eficientemente. El servicio podría tener un montón de memoria disponible, simplemente porque ya no responde solicitudes de los usuarios.
Llevar a cabo un test estándar. Para algunos servicios, podemos realizar un test y entonces medir el tiempo de respuesta del servicio. Comparando el tiempo de respuesta con el tiempo que tenemos como base podemos hacernos una idea sobre si el servicio está dentro del los límites esperados.
Monitorizar el rendimiento mediante el uso de contadores. Los contadores representan la mejor forma de monitorizar el rendimiento actual de un servicio.

Los contadores de rendimiento están incluidos para muchos servicios en Windows Server 2003 y Windows XP Professional, como DHCP, DNS, WINS y IIS. Sin embargo, muchos de los servicios, especialmente los que no vienen con el propio sistema operativo, no incluyen contadores de rendimiento. Esto significa que no seremos capaces de usar contadores de rendimientos para monitorización de todos los servicios en nuestra red.

Para realizar la monitorización podemos utilizar scripts de Shell (TypePerf.exe y Logman.exe) o de WMI (Win32_PerfFormattedData), pero aún así, los contadores pueden usarse desde el monitor de rendimiento, tanto en tiempo real como ir guardando los datos en un archivo.

Un Script para el servicio Web:

   1:     2: StrComputer = "."   3: Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=Impersonate}!\\" & strComputer & "\root\cimv2")   4: Set objRefresher = CreateObject("wbemscripting.SWbemRefresher")   5: Set ColW3SVC = objRefresher.AddEnum (objWMIService, "win32_PerfFormattedData_W3SVC_WebService").ObjectSet   6: objRefresher.Refresh   7: For i = 1 to 60   8:   For each objW3SVC in ColW3SVC   9:     Wscript.Echo "Conexiones  en  este momento: " & objW3SVC.CurrentConnections & _  10:     VbCrLf & "Usuarios anónimos    por segundo: " & objW3SVC.AnonymousUsersPerSec & _  11:     VbCrLf & "Intentos de conexión por segundo: " & objW3SVC.ConnectionAttemptsPerSec & _  12:     VbCrLf & "Usuarios anónimos     conectados: " & objW3SVC.CurrentAnonymousUsers & _  13:     VbCrLf & "Archivos servidos    por segundo: " & objW3SVC.FilesPerSec & _  14:     VbCrLf & "Conexiones  máximas simultáneas : " & objW3SVC.MaximumConnections  15:   Next  16: wscript.Sleep 1000  17: objRefresher.Refresh  18: Next

Como hago lo mismo con el monitor de rendimiento:

Abro el complemento Rendimiento.
Quito los contadores por defecto.
Añado los que quiero y del servicio que quiero, en este caso Web Service.
El monitor muestra información. En concreto, una línea indica el máximo de conexiones permitidas (le he indicado al servicio web sólo 2) y los usuarios anónimos conectados, he conectado desde otro equipo dos ventanas de IE al mismo servicio(2) y es lo que indica.

Monitorizar los Servicios 3

juansa — Mon, 01 Dec 2008 08:38:44 GMT

Monitorizar los cambios en el estado de los servicios mediante Registro de Sucesos

Los cambios en el estado de los servicios no se registraban en en el registro de sistema en versiones de Windows anteriores a Windows Server 2003 y Windows XP. En su lugar, un evento relacionado con un servicio sólo se registraba cuando el servicio fallaba. Esto no ayuda a monitorizar los servicios y su rendimiento en toda la red. Aunque una herramienta de monitorización puede descubrir si un servicio ha sido detenido, no podemos saber quién lo hizo, cuando ni porqué. Por ello, desconocemos si otro administrador o usuario avanzado ha detenido el servicio intencionadamente, o si se ha detenido por un problema de hardware o software.

En Windows Server 2003 y Windows XP professional, sin embargo, los sucesos se registran automáticamente en el registro de sistema siempre que se produzca un cambio en el estado del servicio, o siempre que un código de control se le envió al servicio. Por ejemplo, cuando un servicio cambia de estado, un suceso 7036 se registra:

Este es el evento provocado por la detención del servicio BITS que realicé manualmente para que el script del artículo anterior detectase y guardase en un archivo el cambio de estado de un servicio.

Asimismo, un evento 7035 se grabará cada vez que un código de control sea enviado al servicio.

Ya que podemos usar WMI para recuperar eventos seleccionados desde el registro de sucesos, podemos seguir la fiabilidad del servicio periódicamente consultando al registro de sucesos y anotando las fechas y horas en que los servicios se detienen o inician.

   1: 'Este script sirve para comprobar cambios de estado de los servicios   2: ' usando event log y anotándolo en un archivo de texto   3:     4: '(c) Juansa 29-11-2008   5:     6:     7:     8: Const ForReading = 1, ForWriting = 2   9: Dim TabStop, NewLine  10: TabStop = Chr(9)  11: NewLine = Chr(10)  12: Set objFSO = CreateObject("Scripting.FileSystemObject")  13: Set objFile = objFSO.OpenTextFile("C:\scripts\Servicios_cambios.txt", ForWriting, True)  14:    15: Set dtmConvertedDate = CreateObject("wbemScripting.SwbemDateTime")  16:    17: StrComputer = "."  18: Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=Impersonate}!\\" & strComputer &  "\root\cimv2")  19:    20: Set ColServiceEvents = objWMIService.ExecQuery ("SELECT * FROM Win32_NTLogEvent WHERE LogFile =  'System' AND " & "EventCode = '7036'")  21:    22: For Each strEvent in ColServiceEvents  23:     dtmConvertedDate.Value = strEvent.TimeWritten  24:     objFile.WriteLine dtmConvertedDate.GetVarDate  25:     objFile.WriteLine strEvent.Message  26: Next

Cuyo resultado nos da:

Monitorizar los Servicios 2

juansa — Sat, 29 Nov 2008 09:51:13 GMT

Monitorizar la fiabilidad de los servicios

Monitorizar la fiabilidad de los servicios nos ayudará en su seguimiento y en la medición del tiempo medio existente entre fallos. Este tiempo medio nos indica el tiempo de espera desde que falla un servicio hasta que vuelve a estar operativo. Conociéndolo, tal vez seamos capaces de impedir que ocurran problemas antes de producirse. Por ejemplo, si sabemos que un servicio falla cada 10 días, más que esperar a que falle (momento que podría ser inconveniente para los usuarios) podemos programarlo para que se detenga y reinicie periódicamente; además podemos seguirlo para ver si la solución nos sirve (a veces hay que echar mano de lo que sea).

Este seguimiento también nos puede indicar el tiempo que tarda un servicio en recuperarse del fallo.

Los métodos para seguir la fiabilidad:

Suscripción a sucesos. Podemos crear una suscripción a un suceso que notifique cada x tiempo si un servicio cambia de estado. Si además guarda la información en una BD o archivo que podamos contrastar, podremos realizar un cálculo del tiempo medio entre los fallos y el tiempo necesario para restaurar su funcionalidad completamente.
Registro de sucesos (Event Log). En Windows Server 203 los cambios en el estado de un servicio se guardan en el Registro del Sistema (System Log visible con el Event viewer). Extrayendo periódicamente estos eventos, también podemos calcular la fiabilidad de nuestros servicios.

Si lo hacemos mediante script podemos usar: Shell script (EventQuery.vbs (es), EventTriggers.exe(es), WMI (Colecciones Win32_Service y Win32_NTLogEvent).

Usando una suscripción de sucesos temporal o permanente.
Usando el registro de sucesos.

Monitorizar los cambios en el estado de un servicio con una suscripción de suceso temporal

   1: 'Este script sirve para comprobar cambios de estado de los servicios   2: ' usando una suscripción temporal a event log y volcado en un archivo de texto   3:     4: '(c) Juansa 29-11-2008   5:     6:     7:     8: Const ForReading = 1, ForWriting = 2   9: Dim TabStop, NewLine  10: TabStop = Chr(9)  11: NewLine = Chr(10)  12: Set objFSO = CreateObject("Scripting.FileSystemObject")  13: Set objFile = objFSO.OpenTextFile("C:\scripts\Cambio_Servicios.txt", ForWriting, True)  14:    15:    16: StrComputer = "."  17: Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=Impersonate}!\\" & strComputer & "\root\cimv2")  18: Set objwmiEventSource = objWMIService.ExecNotificationQuery ("SELECT * FROM __InstanceModificationEvent " & "WITHIN 3 WHERE TargetInstance  ISA 'Win32_Service'")  19:    20:   Do  21:     Set objService = objwmiEventSource.NextEvent  22:       If objService.TargetInstance.State <> objService.PreviousInstance.State Then  23:         objFile.WriteLine Date & TabStop & objService.TargetInstance.DisplayName & " está " & objService.TargetInstance.State & ". Anteriormente  estaba " & objService.PreviousInstance.State & "."  24:       end if  25:   Loop  26:  

Este script se ejecuta de continuo, para detenerlo hay que abrir el Administrador de Tareas y matar el proceso wscript.exe que se crea al ejecutarlo.

Se ejecuta y no escribe nada en el archivo, pero yo hago una prueba manual: abro services.msc desde inicio->ejecutar y detengo el servicio (el que sea) Background Intelligent Transfer Service(BITS) y luego lo vuelvo a iniciar. Al echar un vistazo al archivo donde le he dicho que me guarde los cambios, veo:

¿Qué hace el script?

Su cuerpo, ya conocemos la creación y preparación del archivo donde guardará la info, Creamos la variable para el equipo local (StrComputer), Usamos GetObject y conectamos con el espacio de nombres \root\cimv2 con nivel impersonate.

Usamos el método ExecNotificationQuery para registrar la notificación de cada vez que una instancia se modifica. Como sólo queremos los cambios en los servicios, usamos una cláusula WHERE para limitar la monitorización de los datos que nos devuelve la clase Win32_Service.

Creamos un bucle que ejecutará el script indefinidamente (podemos detenerlo como he indicado arriba, o con Taskkill.exe, Cerrando la sesión también se detiene).

Usamos el método NextEvent para recuperar el suceso cuando ocurre.

Así, cada vez que un servicio se modifica de alguna forma, el script comprueba el estado actual con el estado anterior, si no ha cambiado sigue a la espera, si es diferente lo graba en el archivo Cambios_servicios.txt.

Monitorizar los Servicios 1

juansa — Fri, 28 Nov 2008 12:34:12 GMT

Muchas de las operaciones que hace un equipo (especialmente un servidor) es ejecutar servicios. Esto hace que debamos ser cuidadosos con monitorizar los servicios que se ejecutan en los equipos de nuestra red. Una de las maneras más prácticas de monitorización es el uso de scripts.

Muchos de los servicios (DNS, DHCP,...) son críticos y un error en un único servidor puede tener un impacto en cientos, incluso miles, de usuarios, impidiéndoles iniciar sesión o acceder a los recursos de la red.

Como normas más generales de monitorización:

Monitorizar la disponibilidad del servicio: Medir el porcentaje de tiempo que un servicio está disponible.

La definición exacta de disponibilidad depende de lo que se espera de cada servicio. Si un recurso debe estar disponible todos los días de 22:00 a 06:00 horas y éste fallase un domingo a las 8:00 de la mañana, no se consideraría fallo de disponibilidad.

Monitorizar la fiabilidad del servicio: Medir la frecuencia de fallos de un servicio y el tiempo necesario para restaurarlo a su funcionalidad.

La fiabilidad se calcula mediante la división del tiempo que el servicio está en funcionamiento por el número total de días en un año. Por ejemplo,un servicio que ha sufrido paradas en 6 días durante un año tendría una fiabilidad de 98,3% ((359 días disponible)/365 días en un año)

Monitorizar el rendimiento del servicio: Medir si el servicio cumple su tarea en la forma esperada.

Monitorizar la disponibilidad del servicio

Cuando monitorizamos la disponibilidad de un servicio, comprobamos sólo que el servicio se esté ejecutando. Si necesitamos saber si el servicio se ejecuta con máxima eficiencia, necesitamos usar otro tipo de monitorización (el rendimiento). Aunque relativamente es simple, la monitorización de disponibilidad es muy importante; otras cuestiones, como si el servicio se comporta en el nivel esperado, no tienen sentido si no se está ejecutando.

Esta monitorización comprende normalmente una prueba que nos devolverá el estado del servicio. Guardando el resultado de cada prueba en una BD podemos calcular la disponibilidad de un servicio. Si realizamos 100 pruebas y el servicio responde 97 veces, someramente, está disponible un 97%.

La disponibilidad frecuentemente se expresa con la media de tiempo que durante un año el servicio no ha estado disponible.

Para incrementar la disponibilidad de un servicio podemos intentar:

Aumentar el tiempo medio entre fallos: Desafortunadamente, un fallo de servicio es causado frecuentemente por un error del propio servicio o del sistema operativo. A menos que seamos los autores del código, poco podremos cambiar para solucionar el error y así aumentar el tiempo entre fallos.
Disminuir el tiempo necesario para reiniciar el servicio: Si hemos de reiniciar el servicio manualmente cada vez que falle, el servicio no será funcional a menos que lo reiniciemos. Para aumentar la disponibilidad, podemos escribir un script que compruebe su estado y reinicie, en su caso, el servicio automáticamente, periódicamente.

Podemos usar scripts de Shell (sc.exe y net.exe), WSH, WMI (Scriptomatic utility) y ADSI (ADSI Scriptomatic).

Informar sobre la disponibilidad de los servicios puede hacerse mediante:

Informar sobre el estado del servicio.
Informar de los servicios que se encuentran en un estado específico (e.g. en ejecución o detenidos)

Informar del estado de todos los servicios.

   1: 'Este script sirve para comprobar el estado de todos los servicios   2: 'en un archivo de texto   3:     4: '(c) Juansa 28-11-2008   5:     6: Const ForReading = 1, ForWriting = 2   7: Dim TabStop, NewLine   8: TabStop = Chr(9)   9: NewLine = Chr(10)  10: Set objFSO = CreateObject("Scripting.FileSystemObject")  11: Set objFile = objFSO.OpenTextFile("C:\scripts\Estado_Servicios.txt", ForWriting, True)  12:    13: StrComputer = "."  14: Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=Impersonate}!\\" & strComputer & "\root\cimv2")  15: Set colServices = objWMIService.ExecQuery("SELECT * FROM Win32_Service")  16: For each objService in colServices  17: 'escribimos el nombre y el estado del servicio  18: objFile.WriteLine Date & TabStop & objService.DisplayName   19: objFile.WriteLine objService.State  20:    21: Next  22:    23: Wscript.Echo  "FINALIZADO"

El resultado:

* Podemos incluirlo en una tarea programada y realizar la comprobación diaria o a horas determinadas. Se puede incluir además de la fecha, la hora en la que se realiza la comprobación en el script.

Creamos una constante de lectura y escritura
creamos las variables de Tab y Nueva linea
Asignamos los valores de Tab y NewLine
Creamos el objeto del archivo
Abrimos el archivo, indicando su ruta y nombre, para escritura.
variable del equipo, el punto indica equipo local.
conectamos con el espacio de nombres WMI \root\cimv2 con GetObject, estableciendo el nivel de impersonation en impersonate.
Usamos el método ExecQuery para conectar con la clase Win32_Service, lo que nos devolverá una colección que consiste en todos los servicios instalados en el equipo.
Para cada servicio devuelto en la colección, se escribe una nueva línea para la fecha actual y el nombre del servicio y una nueva línea para su estado, en el archivo abierto.
Lanzamos un mensaje al acabar. -Podemos eliminarlo si el script no requiere de nuestra presencia.

Informar sólo de aquéllos servicios que no están en ejecución

   1: 'Este script sirve para listar los servicios en estado detenido en un archivo de texto   2:     3: '(c) Juansa 28-11-2008   4:     5: Const ForReading = 1, ForWriting = 2   6: Dim TabStop, NewLine   7: TabStop = Chr(9)   8: NewLine = Chr(10)   9: Set objFSO = CreateObject("Scripting.FileSystemObject")  10: Set objFile = objFSO.OpenTextFile("C:\scripts\Servicios_detenidos.txt", ForWriting, True)  11:    12: StrComputer = "."  13: Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=Impersonate}!\\" & strComputer & "\root\cimv2")  14: Set colserviciosdetenidos = objWMIService.ExecQuery("SELECT DisplayName, State FROM Win32_Service WHERE State <> 'Running'")  15: 'escribimos el título en el archivo  16: objFile.WriteLine "LISTADO DE SERVICIOS QUE NO SE ESTÁN EJECUTANDO EN FECHA: " & Date  17: objFile.WriteLine  18: For each objService in colserviciosdetenidos  19: 'escribimos el nombre y el estado del servicio  20: objFile.WriteLine objService.DisplayName & ": " & objService.State  21:    22: Next  23:    24: Wscript.Echo  "FINALIZADO"

* El cambio es evidente, hemos modificado la consulta (SELECT) para que sólo devuelva los servicios que no tengan un estado Running.

Crear una tarea en Windows para que se ejecute el script diariamente

Desde Inicio, todos los programas, accesorios, herramientas del sistema, programador de tareas.
Desde la ventana del programador, doble clic en Agregar tarea programada y seguiremos el asistente, primer paso, pulsar siguiente.
Siguiente ventana, pulsaremos en Examinar para ir donde tenemos nuestro script, lo elegiremos y pulsaremos en Abrir del correspondiente cuadro de diálogo.
Elegimos un nombre descriptivo para la tarea, y marcamos la secuencia deseada, en este caso diariamente.
Hora de inicio, frecuencia de días y día de inicio, siguiente.
Datos de la cuenta con la que se ejecutará la tarea. Ojo, si la cuenta no tiene suficientes privilegios no ejecutará la tarea o incluso el script.
Si deseamos configurar alguna opción avanzada o sólo comprobarlas, marcaremos la casilla de verificación y pulsamos en Finalizar.
Avanzadas, ventanas Tarea, Programación, Configuración y Seguridad.
La tarea se ha añadido al programador de tareas.

Script Apagado equipos remotos

juansa — Sat, 11 Oct 2008 17:06:00 GMT

'Este script sirve para apagar una lista de equipos remotos
'listados en un archivo de texto en grupos de dos lineas
'primera linea el nombre del equipo
'segunda linea la ip del equipo

'(c) Juansa 9-10-2008


Function fl_responde_al_ping (StrEquipo)

'aquí intentaremos comprobar que el equipo está conectado
'mediante un ping a su IP.

strComputer = "."
Set objWMIService = GetObject("winmgmts:" _
    & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colPingedComputers = objWMIService.ExecQuery _
    ("Select * from Win32_PingStatus Where Address = '" & StrEquipo & "'")

For Each objComputer in colPingedComputers
    If objComputer.StatusCode = 0 Then
        
    fl_responde_al_ping = True
    Else
        
    fl_responde_al_ping = false
   End If
Next

End Function

'cuerpo del script

Const ForReading = 1, ForWriting = 2
Dim TabStop, NewLine
TabStop = Chr(9)
NewLine = Chr(10)


Set objFSO = CreateObject("Scripting.FileSystemObject")
Set objFSO2 = CreateObject("Scripting.FileSystemObject")
Set objFile = objFSO.OpenTextFile("C:\scripts\juansa.txt", ForReading)
Set objFile2 = objFSO2.OpenTextFile("C:\scripts\LogApagados.txt", ForWriting, True)
Do Until objFile.AtEndOfStream
StrEquipo = objFile.ReadLine
StrIP = objFile.ReadLine

If fl_responde_al_ping(StrIP) then
    Wscript.Echo StrEquipo & " responde. Se intentará realizar el apagado."
    objFile2.WriteLine Date & TabStop & StrIP & TabStop & StrEquipo & TabStop & "APAGADO"

    'establecemos control de errores
    On Error Resume Next

     Set objWMIService = GetObject("winmgmts:" _
& "{impersonationLevel=impersonate,(Shutdown)}!\\" & StrEquipo & "\root\cimv2")
    Set colOperatingSystems = objWMIService.ExecQuery _
("Select * from Win32_OperatingSystem")
    For Each objOperatingSystem in colOperatingSystems
        ObjOperatingSystem.Win32Shutdown(1)
    Next
    if Err.Number <> 0 Then

    'mostramos el error o lo guardamos en el log
    WScript.Echo vbCrLf & vbCrLf & _
                     Err.Number & ": " & Err.Description
    objFile2.WriteLine Date & TabStop & StrIP & StrEquipo & TabStop & "Hay un Error!" & Err.Number & ": " & Err.Description

    'vacíamos el objeto Err
    Err.Clear

    end if 

else
    Wscript.Echo StrEquipo & " NO responde. Se saltará éste equipo del apagado."
    objFile2.WriteLine Date & TabStop & StrIP & TabStop & StrEquipo & TabStop & " NO APAGADO"
end if
Loop
objFile2.Close
objFile.Close
Wscript.Echo "Puedes comprobar el Log en C:\scripts\LogApagados.txt"

----------------

Lo que tienen los archivos:

C:\scripts\juansa.txt

juansa
192.168.0.10
ONO
192.168.0.1
Noexiste
192.168.0.11

C:\scripts\LogApagados

09/10/2008    192.168.0.10    juansa        APAGADO
09/10/2008    192.168.0.1      ONO          APAGADO
09/10/2008    192.168.0.11    Noexiste     NO APAGADO

Este script funciona si el que lo lanza es administrador, de hecho está pensado para lanzarlo un administrador, pero mi amigo Fernando dice que puede usarse http://urpiano.wordpress.com/2007/04/26/vbscript-como-conectar-a-wmi-con-credenciales-alternativas/ para redondearlo.

Por supuesto es mejorable, pero lo publico por sí sirve de ejemplo y ayuda.

Unos scripts...

juansa — Thu, 01 Mar 2007 10:32:00 GMT

Logoff.vbs

set WshShell = CreateObject("WScript.Shell")
WshShell.SendKeys "^{ESC}ul{ENTER}"

Restart.vbs

set WshShell = CreateObject("WScript.Shell")
WshShell.SendKeys "^{ESC}ur{ENTER}"

Shutdown.vbs

set WshShell = CreateObject("WScript.Shell")
WshShell.SendKeys "^{ESC}uls{ENTER}"

Standby.vbs

set WshShell = CreateObject("WScript.Shell")
WshShell.SendKeys "^{ESC}ulss{ENTER}"

Listar las impresoras a un archivo

juansa — Thu, 02 Nov 2006 18:47:00 GMT

'Filename: listprinters.vbs
'Revisión: v1.0
'Author: Juansa
'
'Fecha: 02/11/2006
'Revisado:
'Sintaxis: listprinters.vbs pathtolist

'pathtolist = ruta y archivo donde irán los datos

On error Resume Next

Const ForAppending = 8

'***Comprobamos argumentos***
If WScript.Arguments.count > 0 Then
ArchivoSalida = WScript.Arguments.item(0)
Else
ArchivoSalida = InputBox("Se necesita un nombre de archivo para la lista a generar", "Listado de impresoras")
End If

'***Crear el archivo***

Set objFSO = CreateObject("Scripting.FileSystemObject")
Set objTextFile = objFSO.OpenTextFile (ArchivoSalida, ForAppending, True)

'******

strComputer = "."
Set objWMIService = GetObject("winmgmts:" _
& "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colInstalledPrinters = objWMIService.ExecQuery _
("Select * from Win32_PrinterDriver")
For each objPrinter in colInstalledPrinters
objTextFile.WriteLine("Archivo de configuración: " & objPrinter.ConfigFile)
objTextFile.WriteLine("Fecha del archivo: " & objPrinter.DataFile)
objTextFile.WriteLine("Descripción: " & objPrinter.Description)
objTextFile.WriteLine("Ruta del controlador: " & objPrinter.DriverPath)
objTextFile.WriteLine("Ruta del archivo: " & objPrinter.FilePath)
objTextFile.WriteLine("ARchivo de ayuda: " & objPrinter.HelpFile)
objTextFile.WriteLine("Nombre INF: " & objPrinter.InfName)
objTextFile.WriteLine("Nombre del monitor: " & objPrinter.MonitorName)
objTextFile.WriteLine("Nombre: " & objPrinter.Name)
objTextFile.WriteLine("OEMUrl: " & objPrinter.OEMUrl)
objTextFile.WriteLine("Plataforma compatible: " & objPrinter.SupportedPlatform)
objTextFile.WriteLine("Versión: " & objPrinter.Version)
objTextFile.WriteLine("")
Next
objTextFile.Close
set ObjTextFile = Nothing
wscript.Echo "Hecho!!!"

Como asignar los scripts con directivas

juansa — Fri, 25 Aug 2006 18:19:00 GMT

Para implementar un script, mediante una directiva y añadirlo al elemento apropiado de la plantilla de la propia directiva. Esto es, para que el script se ejecute durante el inicio, apagado, inicio de sesión o cierre de sesión:

Editamos la directiva
Desde el editor, navegamos por el árbol de la consola a la Configuración de usuario/configuración de windows/secuencia de comandos(inicio de sesión/cierre de sesión)
En el panel de detalles, doble-clic en Inicio de sesión
En el cuadro de diálogo de las propiedades de inicio de sesión, clic Agregar.
En el cuadro de diálogo de Agregar, configuraremos los valores que queremos usar y pulsamos Aceptar:

Nombre del script: Escribiremos la ruta al archivo de comandos o pulsaremos en examinar para ubicarlo en el recurso compartido NETLOGON del controlador de dominio.
Parámetros del script: Escribiremos cualquier parámetro que deseamos utilizar de la misma forma que los escribiríamos desde la línea de comandos.

Desde las propiedades de Inicio de sesión (clic derecho) podemos configurar:

Se nos muestra una caja con una lista de todos los scripts que están actualmente asignados en la directiva seleccionada. Si asignamos múltiples scripts, se procesan en el orden que se especificamos. Para mover un script en la lista, usaremos los botones Arriba y Abajo.
Agregar: pulsaremos agregar para especificar scripts adicionales que deseamos utilizar.
Modificar: pulsaremos editar para modificar la información del script, nombre o parámetros, NO el contenido del script.
Quitar: Este botón es para eliminar los scripts seleccionados de la Lista.
Mostrar archivos: Se nos mostrará los scripts que están almacenados en la directiva seleccionada.

Nota: Los archivos de comandos (scripts) se ejecutan en un contexto de cuenta de usuario y no en el de cuenta de administrador.

Asignar scripts con directivas de grupo

juansa — Thu, 24 Aug 2006 14:45:00 GMT

Podemos utilizar las directivas para implantar scripts a los usuarios y equipos. Un script es un archivo de lotes o un vbs (Visual Basic Script) que puede ejecutar código o llevar a cabo tareas de administración. Podemos usar los valores de script de las directivas para automatizar el proceso de ejecución de scripts.

Hay valores de script bajo ambas configuraciones, de equipo y de usuario, de la directiva. Podemos usar una directiva para ejecutar un script cuando se inicia o apaga un equipo y cuando un usuario inicia o cierra sesión. Como con todos los valores de directiva podemos configurar el script en la directiva una vez y Windows Server 2003 aplicarlo e implementarlo continuamente por toda tu red.

¿Cuales son los valores de script de directiva?

Estos valores podemos usarlos para centralizar la configuración de los scripts y ejecutarlos en las situaciones mencionadas. Podemos especificar cualquier script que funcione en Windows Server 2003, archivo de lotes, ejecutables y cualesquiera script compatible por Windows Script Host (WSH).

Para ayudarnos a administrar y configurar el entorno de los usuarios, podemos:

Ejecutar scripts que lleven a cabo tareas que no podemos hacer por medio de otros valores de directiva. Por ejemplo, entorno de usuario con conexiones de red, conexiones de impresoras, accesos directos a aplicaciones y documentos corporativos.
Limpiar los escritorios cuando los usuarios cierran sesión o apagan el equipo. Podemos quitar conexiones que se hayan añadido con otros scripts de inicio y dejar el equipo en el mismo estado antes de que iniciase sesión el usuario.
Ejecutar scripts ya existentes para gestión del entorno de usuarios hasta que configuremos otros valores de directiva que los replacen.

Nota: Desde usuarios y equipos de Active Directory, podemos asignar scripts de inicio de sesión individualmente a cuentas de usuario en el cuadro de diálogo de propiedades para cada cuenta. Sin embargo, implantarlos con directivas es preferible para la ejecución de scripts, porque podemos administrarlos de forma centralizada, junto al inicio, apagado, y cierre de sesión.

Centro de Scripts de Microsoft http://www.microsoft.com/technet/scriptcenter/default.mspx

Mapear unidades de red según la pertenencia a grupo del usuario

juansa — Thu, 23 Feb 2006 12:09:00 GMT

Function fl_Es_Miembro(str_Grupo)
'**************************************************************************************************
'
'Autor: Fernando Reyes
'
'Esta función tiene por finalidad encontrar la pertenencia a un determinado grupo (que se recibe
'como parámetro) de el usuario que lanza el script. La devolución es booleana: en caso de que el
'usuario pertenezca al grupo devuelve True; en caso de no pertenencia devuelve False.
'
'**************************************************************************************************

Dim str_ADs_Path 'Cadena utilizada para generar la ruta ADSI del usuario
Dim obj_Usuario 'Objeto que se cargará con la información del usuario
Dim obj_Grupo 'Objeto para cada cargar la información de un grupo
Dim obj_Net 'Objeto Network del que partimos para obtener el objeto usuario

'Creamos el objeto Network
Set obj_Net = CreateObject("Wscript.Network")

'Montamos la ruta ADSI del usuario y creamos el objeto de usuario
str_ADs_Path = obj_Net.UserDomain & "/" & obj_Net.UserName
Set obj_User = GetObject("WinNT://" & str_ADs_Path & ",user")

'En este bucle vamos recorriendo uno a uno los grupos a los que pertenece el usuario
For Each obj_Grupo In obj_User.Groups

'Si el grupo coincide con el recibido como parámetro salimos de la función
'devolviendo True
If StrComp(str_Grupo, obj_Grupo.Name, vbTextCompare) = 0 Then
fl_Es_Miembro =True
Exit Function
End If

'Si hemos terminado el bucle, es porque no se ha encontrado el grupo recibido entre
'aquellos a los que pertenece el usuario, por tanto la devolución de esta función
'será False
fl_Es_Miembro = False

End Function

'Ejemplo de cómo se utilizaría la función para montar una unidad "S: "a los usuarios del grupo "Esclavos de Tercera"

If fl_Es_Miembro("Esclavos de Tercera")=True Then

'creamos el objeto NetWork que utilizaremos para montar la unidad
Set obj_Net = CreateObject("Wscript.Network")

'Mapeamos la unidad
obj_Net.MapNetworkDrive "s:", "\\servidor\carpeta_de_los_esclavos_de_tercera"

EnD If

Listar Usuarios y grupos locales

juansa — Tue, 20 Dec 2005 14:47:00 GMT

Listar Usuarios y grupos locales

'Este script enumera los usuarios que pertenecen a cada
'uno de los grupos locales de un equipo
'© Fernando Reyes [MS MVP] - Abril de 2005
'Modified: Juansa [MS MVP Windows Server]
'
'Date: 11/04/2005
'Revised: 15/12/2005
'Sintaxis: UserGroupsLocal.vbs ficheroSalida

'Exigimos la declaración de variables
Option Explicit

Dim obj_Nombre_Usuario
Dim obj_Nombre_Grupo
Dim obj_Equipo
Dim obj_Grupo
Dim obj_Shell
Dim str_Equipo
Dim str_Nombre
Const ForReading = 1, ForWriting = 2, ForAppending = 8

'Argumentos
If WScript.Arguments.count > 0 Then
FicheroSalida = WScript.Arguments.item(0)
Else
FicheroSalida = InputBox("Nombre del fichero a crear", "Gestion de usuarios")
End If

'Creación fichero salida
Set objFSO = CreateObject("Scripting.FileSystemObject")
Set objTextFile = objFSO.OpenTextFile (FicheroSalida, ForWriting, True)

'Equipo local
str_Equipo = "."
Set obj_Shell = CreateObject("WScript.Shell")
str_Nombre = obj_Shell.ExpandEnvironmentStrings("%COMPUTERNAME%")

'Creamos un objeto que contiene el equipo local
Set obj_Equipo = GetObject("WinNT://" & str_Equipo & ",Computer")

'Mostramos el nombre del equipo
WScript.Echo "Equipo: " & str_Nombre & VBCrLf

'Filtramos los objetos del equipo para obtener los grupos
obj_Equipo.Filter = Array("Group")

'Recorremos cada grupo uno a uno
For Each obj_Nombre_Grupo In obj_Equipo

'Creamos un objeto que contiene al grupo actual
Set obj_Grupo = GetObject("WinNT://" & str_Equipo & "/" & obj_Nombre_Grupo.Name & ",Group")

objTextFile.WriteLine("Nombre del grupo : " & obj_Nombre_Grupo.Name)
objTextFile.WriteLine(" Descripción del grupo: " & obj_Nombre_Grupo.Name)

      'Filtramos los objetos del grupo para obtener los
      'usuarios miembros
       obj_Grupo.members.Filter = Array("User")

      'Recorremos los usuarios de uno en uno
       For Each obj_Nombre_Usuario In obj_Grupo.members
       set M = obj_Nombre_Usuario
       objTextFile.WriteLine("                  " & obj_Nombre_Usuario.Name)
       Next

WScript.Echo "Finalizado, vea el archivo creado!"
'Terminamos el script limpiándonos el culito
Set obj_Nombre_Usuario = Nothing
Set obj_Nombre_Grupo = Nothing
Set obj_Equipo = Nothing
Set obj_Shell = Nothing

Obtener log con las sesiones contra Terminal Server

juansa — Tue, 20 Dec 2005 14:46:00 GMT

' Tomas Hidalgo (c) Abril 2005
' Script para almacenar los accesos al Terminal Server.
' Los datos se almacenan entre comillas y separados por comas en un fichero de texto.
Const ForAppending = 8
Set oShell = CreateObject("WScript.Shell")
Set objFSO = CreateObject("Scripting.FileSystemObject")
'****************************************************************************
'Comprobamos si existe el fichero de log
If objFSO.FileExists("C:\acceso.log") Then
    'No hacemos nada
Else
    'El fichero no existe y lo creamos con la cabecera de datos
    Set objArchivo = objFSO.CreateTextFile("c:\acceso.log", true)
    objArchivo.Write chr(34) & "Fecha" & chr(34) & ","
    objArchivo.Write chr(34) & "Hora" & chr(34) & ","
    objArchivo.Write chr(34) & "Equipo" & chr(34) & ","
    objArchivo.Write chr(34) & "Usuario" & chr(34) & ","
    objArchivo.Write chr(34) & "Tipo_Conexion" & chr(34) & ","
    objArchivo.Writeline
    objArchivo.close
End If
'****************************************************************************
'Para obtener la fecha del sistema
strComputer = "."
Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colItems = objWMIService.ExecQuery("Select * from Win32_UTCTime")
For Each objItem in colItems
    Dia = objItem.Day
    Mes = objItem.Month
    Anno = objItem.Year
    Hora = objItem.Hour
    Minu = objItem.Minute
Next
strFecha = Anno & "/" & Mes & "/" & Dia
strReloj = Hora & ":" & Minu
'****************************************************************************
'Leemos los datos del cliente TS
strSesion = oShell.ExpandEnvironmentStrings("%SESSIONNAME%")
strUsuario = oShell.ExpandEnvironmentStrings("%USERNAME%")
strMaquina = oShell.ExpandEnvironmentStrings("%CLIENTNAME%")
'Comprobamos el tipo de conexion
If strSesion = "" Or LCase(strSesion) = "console" Then
strSesion = "Acceso por consola"
End If
If Left(strSesion,8) = "RDP-Tcp#" Then
strSesion = "Acceso por TS"
End If
'Agregamos los datos al fichero
Set objArchivo = objFSO.OpenTextFile("c:\acceso.log", ForAppending, False)
objArchivo.Write chr(34) & strFecha     & chr(34) & ","
objArchivo.Write chr(34) & strReloj      & chr(34) & ","
objArchivo.Write chr(34) & strMaquina & chr(34) & ","
objArchivo.Write chr(34) & strUsuario & chr(34) & ","
objArchivo.Write chr(34) & strSesion    & chr(34)
objArchivo.Writeline
objArchivo.close

Mapear unidades de usuario

juansa — Tue, 20 Dec 2005 14:46:00 GMT

'**********************************************
Option Explicit
Dim oNet, sUser, startTime

On Error Resume Next

'Objeto Red
Set oNet = CreateObject("WScript.Network")

'Obtenemos el login de usuario. En Windows 9x, el usuario puede no estar todavía autentificado
'cuando el script comienza a ejecutarse; En ese caso reitera cada 1/2 segundo
sUser = oNet.UserName 'En minúsculas

startTime = Now
Do While sUser = ""
   If DateDiff("s", startTime, Now) > 600 Then Wscript.Quit
   Wscript.Sleep 500
   sUser = oNet.UserName
Loop

'Mapeado de la unidad F particular de cada usuario

oNet.RemoveNetworkDrive "U:"
oNet.MapNetworkDrive "U:", "\\servidor\usuarios\" & sUser

oNet.RemoveNetworkDrive "X:"
oNet.MapNetworkDrive "X:", "\\servidor\comunes\"

'**********************************************
Toda la explicación en:

http://msmvps.com/quilez/archive/2005/02/04/34940.aspx