Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

06.- Monitor de rendimiento. Conjunto recopiladores datos. Alertas rendimiento - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 13 de febrero de 2024 por Fernando Jesús H.

58 visualizaciones

Más información Transcripción

Buenas, en el último vídeo estuvimos creando un conjunto de recopiladores de datos referido al contador de rendimiento. 00:00:00
Entonces, no sé si recordáis que creamos este que se llamaba Contador 1, en el que teníamos un contador de rendimiento. 00:00:08
Y os recuerdo que teníamos que iba a medir el contador de megas disponibles del objeto memoria, cada minuto, en formato binario. 00:00:16
de acuerdo, le pusimos aquí un ficherito de ejemplo que iba a tener 00:00:26
de forma que se iba a llamar el nombre del equipo PC01 00:00:31
este es el ejemplo de lo que tiene el PC01 00:00:34
seguido de contar CPU, seguido de el año y el mes completo 00:00:39
no sé si recordáis, y que además le pusimos en contador, botón derecho, propiedades 00:00:44
que le pusimos que durase 00:00:50
Vale, yo tengo puesto aquí 30 segundos. ¿Por qué os digo esto? Porque ahora vamos a ver lo que son las alertas, entonces vamos a aprovechar que este lo hicimos en el vídeo anterior y vamos a utilizar este para que cuando la alerta salte, pues que se ejecute este contador de rendimiento. 00:00:55
Entonces, ¿qué es lo que vamos a ver ahora? Las alertas 00:01:11
Una alerta es una característica que detecta si un valor de contador predefinido supera 00:01:16
O está por debajo de un límite especificado 00:01:22
Como por ejemplo, que el procesador que es el que vamos a hacer aquí supere el 90% 00:01:24
Que el número de bytes recibidos supere tantos megas por segundo, etc, etc 00:01:29
Eso ya depende, el límite establecido depende del contador que nosotros elijamos 00:01:34
Entonces, el límite que nosotros especifiquemos del contador se denomina umbral de alerta 00:01:38
El umbral se establece según la línea base y se configuran notificaciones 00:01:46
Me explico, o sea, yo primero tengo establecido cuál es la línea base que tendría que tener 00:01:52
Y a partir de ahí establezco un umbral 00:01:58
Entonces lo que le digo es que salte una alerta cuando supere o cuando esté por debajo de dicho umbral que yo he definido. 00:02:01
Entonces, para no dar todo rato teoría, vamos a ir viendo. 00:02:10
Vamos a crear una alerta que lo que haga es saltar cuando nuestro procesador supere el 96%, por ejemplo. 00:02:13
Entonces nos vamos a ir a definido por el usuario, botón derecho, nuevo y conjunto de recopiladores de datos. 00:02:22
Uy, perdonad. 00:02:29
nuevo y conjunto de recopiladores de datos 00:02:31
recuerdo donde estamos 00:02:35
y le vamos a poner aquí 00:02:39
alerta CPU por ejemplo 00:02:44
seleccionamos crear manualmente 00:02:49
hemos puesto el nombre 00:02:52
hemos puesto crear manualmente 00:02:54
le damos a siguiente 00:02:57
y aquí vamos a seleccionar alerta del contador de rendimiento 00:02:58
de acuerdo, que es el que nos queda ver en estos vídeos 00:03:02
le damos a siguiente 00:03:08
y ahora aquí vamos a poner que queremos meter 00:03:09
que contador de rendimiento 00:03:13
porque esto es igual que el otro 00:03:14
esto es igual que cuando hicimos los contadores de rendimiento 00:03:15
le damos al botón de agregar 00:03:18
y vamos a buscar aquí el típico que hace todo el mundo 00:03:20
el procesador, objeto procesador 00:03:24
El contador, tanto por ciento del procesador 00:03:27
Y vamos a seleccionar el total 00:03:30
Le damos a agregar 00:03:31
Ya lo tenemos 00:03:33
De forma que, repito, hemos seleccionado del procesador 00:03:34
Hemos seleccionado el tanto por ciento del contador 00:03:38
Y hemos seleccionado la instancia que me pone el total de todos los cores 00:03:41
Le hemos dado a agregar 00:03:45
Me aparece aquí 00:03:47
Y por último le damos a aceptar 00:03:48
¿De acuerdo? 00:03:51
Esto es lo que hemos ido haciendo 00:03:53
una pared de aquí y tenemos aquí 00:03:54
una vez que lo tenemos, tenemos que decir el umbral 00:03:59
entonces le vamos a decir que por encima o por debajo 00:04:04
entonces le vamos a decir que cuando esté por encima de, hemos dicho 96, ¿no? 00:04:07
el 96%, ¿vale? porque ya os digo que depende del contador 00:04:12
pues será este número, será un tanto por ciento, será mega, será segundo 00:04:16
será dependiendo del contador que nosotros establezcamos 00:04:20
Entonces le vamos a decir que cuando esté por encima de 96 que salte 00:04:22
Le decimos a siguiente 00:04:26
Dejamos que lo que quiero simplemente es guardar y cerrarlo 00:04:27
Ya vimos que puedo abrir las propiedades ahora que no quiero 00:04:32
O puedo iniciar este conjunto recuperador 00:04:34
Es decir, esta alerta ahora 00:04:36
Seleccionamos guardar y cerrar y le damos a finalizar 00:04:38
Entonces quiero que veáis que me ha creado aquí la alerta 00:04:41
¿De acuerdo? 00:04:44
A mí esto no me gusta mucho, ya os dije por qué 00:04:44
Porque dentro me ha puesto el Data Collection 1 00:04:46
Que no me hace mucha gracia, pero bueno 00:04:49
Entonces vamos a ver cuáles son las propiedades que tiene esta alerta, entonces repito donde estoy por si estáis perdidos, hemos creado este conjunto de recopiladores de datos que lo que hemos es creado simplemente una alerta, entonces vamos a ver ahora que propiedades tiene esta alerta, entonces botón derecho encima de la alerta y en propiedades. 00:04:50
Entonces, fijaros que aquí tenemos los contadores que nosotros hemos añadido, ¿de acuerdo? 00:05:11
Si tuviésemos varios, nosotros podríamos seleccionar cada uno y seleccionar el umbral. 00:05:21
Aquí solamente lo hemos hecho con uno. 00:05:27
Entonces, tenemos lo mismo que hemos hecho antes. 00:05:29
Tenemos el contador que hemos seleccionado. 00:05:33
Le hemos dicho que cuando esté por encima del 96%. 00:05:36
Y ahora aquí abajo, que me pone el intervalo, nos permite indicar el tiempo que se estará tomando datos y en qué unidades 00:05:39
Entonces nos permite indicar las unidades del tiempo indicado en el punto anterior, es decir, en el 15 00:05:46
Entonces nosotros vamos a decirle aquí que va a tomar muestras cada, yo qué sé, 3 segundos 00:05:52
¿De acuerdo? Entonces cada 3 segundos va a ir mirando cuál es el límite del procesador 00:05:59
Y si supera el 96% pues me genera la alerta 00:06:03
¿De acuerdo? 00:06:06
Aquí nos hace falta decir que nosotros podemos agregar más contadores para alerta o podemos seleccionar el que queremos y lo podemos quitar. 00:06:10
Esto en cuanto a la ficha alerta. 00:06:18
¿Qué pasa con la ficha acción de alerta? 00:06:20
Si lo seleccionamos, en esta ficha vamos a poder indicar si deseamos registrar una entrada en el registro de eventos de aplicación cuando se produzca una alerta. 00:06:23
Y además si deseamos iniciar un conjunto de recuperadores de datos. 00:06:34
Si pulsamos en la flechita que aparece en el desplegable, pues nos aparecerán conjuntos recopiladores de datos. Es decir, que si nosotros queremos que cuando salte la alerta se quede registrado en el visor de eventos, dentro del registro voy a tener que seleccionar este. 00:06:38
Si quiero que además que cuando salte la alerta se ejecute un conjunto de recopiladores de datos 00:06:56
Seleccionamos aquí cual queremos 00:07:03
Entonces nosotros luego vamos a seleccionar aquí pues el que hemos creado en el apartado anterior 00:07:05
En el vídeo anterior que se llamaba contador 1 00:07:11
¿De acuerdo? 00:07:12
Y en la ficha tareas de alerta 00:07:14
Tenemos los siguientes apartados 00:07:17
el que me pone ejecute esta tarea cuando se desencadene la alerta 00:07:21
vamos a poder indicar una tarea del instrumental de administración de Windows 00:07:28
es decir, una tarea programada que se ejecutará cuando se desencadene la alerta 00:07:34
en cuanto a dicha tarea nosotros le vamos a poder pasar una serie de argumentos 00:07:38
entonces aquí vamos a poder indicar los argumentos de la tarea 00:07:44
que hemos indicado en el apartado justamente anterior 00:07:47
Estos argumentos, yo puedo escribir aquí el texto que me dé la gana o puedo poner una serie de variables 00:07:51
Si yo pincho aquí en este botoncito, pues yo tengo una serie de variables 00:07:57
Es decir, que si yo pongo entre llaves el name, lo que va a hacer es traducir por el nombre de la alerta correspondiente 00:08:01
Yo pongo la fecha en que ha saltado la alerta, me pone cuál es el umbral que ha tenido 00:08:10
me pone que se ha traspasado el umbral 00:08:18
el que tengo establecido que es 96% 00:08:21
el valor actual del contador 00:08:23
que ha producido que salte 00:08:25
y un texto que si yo selecciono user test 00:08:27
lo voy a tener que decir aquí abajo 00:08:30
entonces eso es para que yo ponga aquí el texto que yo quiero 00:08:33
y me aparece 00:08:37
con los tres que tengamos aquí 00:08:37
pues aquí veis un ejemplo de que es lo que va a enviar 00:08:40
entonces todo esto lo vamos a hacer ahora 00:08:43
para que veáis todas las opciones que tenéis con la alerta 00:08:45
Entonces, por ahora, si yo esta alerta la ejecuto, ¿vale? Yo cojo alerta CPU y le doy aquí al play. Aquí realmente no estamos haciendo ahora nada porque esto no se queda reflejado en ningún lado. 00:08:48
Acordaros que yo le he dicho que puedo que cuando supere el umbral y se genere la alerta, se me quede reflejado en el visor de eventos. 00:09:04
Entonces vamos a hacer una cosa, voy a abrir el visor de eventos, que aquí es donde se me quedaría reflejado todo y que sepáis que todo lo relacionado con lo del conjunto de recopiladores de datos, os digo donde se me queda. 00:09:12
Entonces lo voy a poner más pequeño en este lado 00:09:27
Entonces dentro del visor de eventos 00:09:30
Nos vamos a ir 00:09:36
Al que se llama registro de aplicaciones 00:09:37
Uy, perdón 00:09:39
Me voy a ir 00:09:40
Sí, estaba bien 00:09:42
Espérate que está cargando 00:09:43
Me voy al registro de aplicaciones y servicios 00:09:44
Dentro de registro y aplicaciones y servicios 00:09:46
Me voy a Microsoft 00:09:51
Estoy pulsando muchas veces 00:09:53
Me voy a Windows 00:09:58
Y me voy aquí 00:10:00
Al que se llama 00:10:04
Diagnostic Plus 00:10:07
Y dentro, operativo 00:10:13
¿Vale? Entonces repito donde me he ido, lo pongo por aquí para que me veáis. 00:10:23
He seleccionado, me he metido en el visor de eventos, me he metido en registros de aplicaciones y servicios, me he metido en Microsoft, me he metido en Windows y he seleccionado abajo el que se llama Diagnostics. 00:10:31
pongo aquí 00:10:46
el que se llama 00:10:47
diagnostic plus y dentro de aquí 00:10:49
pues el log que se llama operativo 00:10:52
entonces quiero que veáis que aquí 00:10:54
a mano derecha pues me aparece 00:10:56
todo lo que voy haciendo 00:10:58
yo no sé si veis que aquí me pone 00:10:59
el usuario 00:11:01
el usuario 00:11:03
creó un conjunto recuperado de datos 00:11:05
alerta CPU que es lo que hemos creado ahora 00:11:07
entonces si yo voy pinchando aquí y voy bajando 00:11:09
elimino el conjunto 00:11:11
de alerta 1 00:11:13
porque estos son ejemplos que he ido haciendo otros días 00:11:14
entonces aquí para que veamos de que va la cosa 00:11:19
voy a vaciar este log 00:11:21
entonces tenéis aquí a mano derecha 00:11:23
el vaciar log 00:11:25
como estoy en un laboratorio y en una prueba 00:11:27
no pasa nada porque no lo guardemos 00:11:31
le voy a dar directamente a borrar 00:11:33
porque quiero que veáis todo lo que se va generando 00:11:34
entonces le doy a borrar 00:11:37
de acuerdo 00:11:39
entonces voy a arrancar ahora la alerta 00:11:40
selecciono el contador, la alerta correspondiente, alerta CPU, le doy al play, entonces ahora está todo el rato escuchando cada 3 segundos 00:11:44
y si el procesador supera el 96% me genera una alerta, si yo me voy al visor de eventos y yo me voy aquí a actualizar, estoy aquí, le doy a actualizar 00:11:53
para que me vaya refrescando que lo que hay aquí, pues aquí lo único que me ha dicho es que se cambió el conjunto recopilador de datos de la CPU 00:12:05
y que se inició 00:12:14
¿de acuerdo? es decir, no me dice nada más 00:12:17
voy a probar 00:12:19
y voy a poner la CPU al 100% 00:12:21
entonces, para probar eso 00:12:23
yo tengo aquí este programita, que es el que veo en todos los vídeos 00:12:24
que es una mierda de programita, pero bueno 00:12:27
entonces, que se llama OCCT 00:12:28
le damos, yo tengo aquí la versión Trial 00:12:30
que lo que hace es hacer un 00:12:33
un benchmark, someter a mi procesador 00:12:35
le digo que sí 00:12:37
entonces, esto es lo que me va a poner 00:12:38
mi procesador al 100% 00:12:41
Le pincho aquí en Start 00:12:42
Este lo podéis descargar de por ahí, ¿vale? 00:12:50
Entonces, como no tengo la versión 00:12:59
Full, por decirlo 00:13:00
Pues tengo que esperar un poquito 00:13:02
¿Vale? Entonces, yo ahora cuando le dé al Start 00:13:03
¿Vale? ¿Qué es lo que me va a poner? 00:13:06
El procesador 100% 00:13:08
Voy a abrir el administrador de tareas 00:13:09
me voy aquí a rendimiento 00:13:11
y vais a ver que la CPU 00:13:13
se me pone al 100%, entonces yo le doy 00:13:15
aquí al Start 00:13:17
y quiero que veáis que se me está poniendo 00:13:17
la CPU al 100%, ¿vale? 00:13:23
entonces cada 3 segundos 00:13:25
está sometiendo al procesador 00:13:26
y supuestamente 00:13:29
la alerta ha tenido que superar, le voy a 00:13:31
dar al Stop ya, ¿vale? porque ya con esto 00:13:33
ya ha pasado 3 segundos, le voy a dar el Stop 00:13:35
esto lo voy 00:13:37
a volver hacia atrás 00:13:39
y lo voy a dejar para la siguiente vez 00:13:41
entonces, ¿qué es lo que ha pasado aquí? 00:13:42
si yo me voy al visor de eventos 00:13:45
y esto lo refresco 00:13:48
le doy a actualizar 00:13:49
veis que aquí no está pasando nada 00:13:50
¿por qué? 00:13:53
porque nosotros en la alerta 00:13:54
no hemos establecido nada 00:13:55
o sea, hemos hecho una alerta 00:13:56
pero no le hemos dicho 00:13:57
qué es lo que queremos que haga 00:13:58
cuando salte la alerta 00:14:00
entonces no se me está quedando reflejado en ningún lado 00:14:01
entonces nos vamos a ir 00:14:03
y vamos a ir haciendo paso a paso 00:14:05
qué es lo que podemos hacer 00:14:06
entonces la voy a parar 00:14:08
la selecciono, la voy a parar 00:14:09
si yo me voy aquí a informes, definido, me voy aquí a alertas 00:14:13
no penséis que aquí me va a aparecer una gráfica de más 00:14:18
entonces vamos a empezar el primer paso 00:14:21
vamos a configurar la alerta 00:14:23
me voy a ir aquí al data collection, botón derecho, propiedades 00:14:26
me voy a ir 00:14:29
y aquí me ha puesto 15 segundos, ¿no lo hemos guardado? 00:14:31
bueno, aplicar 00:14:34
y aceptar que no lo habíamos guardado 00:14:37
esperamos, indistintamente no tiene que pasar nada 00:14:40
lo vuelvo a hacer otra vez 00:14:43
le doy al play 00:14:44
someto al procesador al 100% 00:14:48
espero 3-4 segundos 00:14:53
entonces ya ha tenido que saltar la alarma 00:14:59
le doy al stop 00:15:01
y miramos que ha hecho 00:15:03
entonces si me voy al visor de eventos 00:15:07
le doy a actualizar 00:15:12
vale, aquí me dice que se inició 00:15:15
se cambió 00:15:20
se cambió, es decir, aquí 00:15:21
no veo en ningún lado que me diga 00:15:23
que la alerta ha saltado 00:15:25
voy a vaciarlo otra vez 00:15:27
y vamos a editar 00:15:29
la alerta, botón derecho propiedades 00:15:32
Y ahora me voy a ir a la pestaña acción de alerta y voy a seleccionar el que me pone registrar una alerta de entrada de registro de eventos de aplicación. 00:15:36
Simplemente con eso, le digo aplicar, me dice que no lo he parado, así que hasta que no lo pare lo paro, porque me dice que hasta que no lo pare no se va a aplicar la nueva actualización, porque pensaba que lo había parado pero no lo he parado. 00:15:47
Bien, Fernando. Entonces hemos seleccionado registrar una entrada en el registro de eventos de aplicación. Le doy a aceptar. Y le damos aquí otra vez al play. Lo seleccionamos y le damos al play. ¿De acuerdo? Ya me está funcionando. Voy a someter otra vez el procesador al 100%. Le digo start. 00:16:02
de acuerdo, se me pone el procesador al 100% 00:16:19
y os recuerdo que hemos puesto que cada 3 segundos 00:16:24
me va a coger una muestra 00:16:27
entonces ya han pasado 00:16:28
12 segundos, así que 00:16:30
lo paramos 00:16:32
y vamos a ver que es lo que ha hecho esto 00:16:33
entonces si me voy ahora al visor de eventos 00:16:36
si le doy a actualizar 00:16:40
os recuerdo donde le estoy dando 00:16:42
todo el rato 00:16:45
quiero que veáis que es lo que aparece 00:16:45
si yo lo hago en este botón derecho 00:16:52
y ver las propiedades o le hago doble clic 00:16:55
me da igual 00:16:58
quiero que veáis que me dice 00:16:58
el contador de rendimiento procesado total 00:17:02
de tiempo de procesador 00:17:05
superó el umbral de alerta 00:17:06
el valor de contador es 100% 00:17:08
porque estaba el procesador a 100% 00:17:11
se encuentra por encima del límite 00:17:13
Que era 96. Entonces, fijaros que como yo le he dicho que queda registrado este evento, pues tirándome ellas, ¿de acuerdo? ¿Qué es lo que podemos hacer aquí ahora? Pues quiero que veáis, lo voy a poner un poquito más para allá, quiero que veáis que el identificador de evento que se genera asociado al que ha saltado la alerta, ¿vale? Esto tengo otro vídeo explicando cuáles son los identificadores de eventos y demás, pero quiero que veáis que es el 2031, ¿vale? No sé si lo llegáis a ver aquí. 00:17:15
Estoy seleccionando el identificador 2031, ese es el que se ha generado cuando se ha generado una alerta, ¿vale? 00:17:45
Porque teníamos el contador de rendimiento y ha superado el umbral. 00:17:52
Entonces nosotros podemos generar y decirle que cuando este evento se genere, pues que se realice una tarea. 00:17:56
Y lo podemos hacer desde aquí, desde el propio visor de eventos, ¿vale? 00:18:02
Yo le puedo decir botón derecho, le puedo decir a juntar tarea a este evento. 00:18:06
Estoy aquí. 00:18:15
Y aquí me dice, a ver, ¿cómo quieres llamar la tarea? 00:18:22
Pues esta misma, ¿vale? Para que no sea tan larga. 00:18:25
Pues, superación, alerta, CPU. 00:18:29
Ponemos una descripción. 00:18:36
Yo ahora, dejarme que me la salte, le doy a siguiente. 00:18:37
me dice que esto se va a producir cuando se registre el evento dentro del diagnóstico cooperativo 00:18:41
referente al ID 2031 00:18:48
le decimos siguiente 00:18:51
y me dice que es lo que quieres hacer 00:18:53
fijaros que aquí me da tres opciones de enviar un correo 00:18:56
que eso ya no se utiliza, es más, lo está probando y ya no funciona 00:18:59
y lo ha demostrado un mensaje tampoco 00:19:02
así que vamos a seleccionar que quiero iniciar un programa 00:19:04
le digo a siguiente y aquí tenemos que poner el programa 00:19:07
con las opciones que yo le quiera pasar 00:19:11
¿vale? pues aquí voy a hacer una pausa 00:19:13
vamos a abrir el PowerShell 00:19:15
porque no se me ocurrió otra cosa de 00:19:16
que cuando se genere 00:19:19
este evento me aparezca un mensajito en la 00:19:21
pantalla diciendo pues te has pasado 00:19:23
¿vale? yo que sé, alguna cosita 00:19:25
entonces vamos a hacerlo con PowerShell 00:19:26
aquí podéis hacer diferentes opciones 00:19:29
¿de acuerdo? pero bueno 00:19:31
yo he elegido PowerShell pues no lo sé por qué 00:19:32
entonces voy a abrir el PowerShell 00:19:35
y aquí tenéis una manera de 00:19:36
mostrar una ventanita el mensaje que vosotros queráis vale para eso primeramente tenéis que 00:19:39
ejecutar este comando vale que se llama add type a simple name y le vais a pasar el presenta el 00:19:44
presentation core y el presentation framework si yo le doy vale parece que no me ha hecho nada 00:19:51
si buscáis aquí en la ayuda el add type pues fijaros que aquí en la ayuda te dice que añade 00:19:57
en este caso clases a la sesión de PowerShell para que la podáis utilizar 00:20:07
entonces estas clases me interesan para que yo pueda generar una ventanita 00:20:12
¿de acuerdo? entonces repito lo que hemos ejecutado aquí 00:20:16
este comando 00:20:20
¿de acuerdo? y ahora ya podemos crear una ventanita 00:20:21
que esta ventanita tenéis 00:20:27
este comando que os explico en que consiste 00:20:29
Entonces aquí le digo entre corchetes cuál es la clase que quiero utilizar, una que se llama MessageBox, le digo que hay un método que se llama Show y en este método le podéis pasar cuatro argumentos. 00:20:34
El contenido de la ventanita, que yo voy a poner CPU muy utilizada 00:20:50
El título de la ventanita, que le he puesto utilización de CPU 00:20:55
Luego, los botones que queréis que aparezca 00:20:59
Tenéis varias opciones, ¿vale? 00:21:02
Pues yo he puesto que solamente me aparezca un botón de OK 00:21:05
Y el icono que queréis que os aparezca 00:21:07
Podéis decirle que queréis un icono de información, de warning, de error, ¿de acuerdo? 00:21:10
Entonces, si buscáis por ahí la ayuda del comando show 00:21:15
Pues os muestra todos los iconos y demás que podéis tener 00:21:17
Vale, he puesto aquí esta página web 00:21:22
¿De acuerdo? 00:21:25
Donde tenéis un ejemplo de cómo lo utilizas 00:21:26
Pero a lo que voy 00:21:31
Los botones 00:21:32
Podéis poner OK, OK Cancel, Yes, No, Yes, No Cancel 00:21:33
O los iconos 00:21:36
Podéis poner Stop 00:21:38
Podéis poner Question, Warning 00:21:39
Que es el que he puesto yo 00:21:41
O en este caso Asterix 00:21:42
¿De acuerdo? 00:21:44
Entonces aquí tenéis varias opciones 00:21:45
Incluso no solamente cómo mostrar un mensaje 00:21:46
Sino cómo mostrar una notificación 00:21:49
Abajo a mano izquierda, ¿de acuerdo? 00:21:51
Entonces no sé si llegáis a ver 00:21:53
Que tenemos aquí la web correspondiente 00:21:54
¿De acuerdo? 00:21:57
Pues si le damos aquí al Enter 00:22:01
Quiero que veáis lo que sale 00:22:03
¿Veis que me sale CPU muy utilizado? 00:22:04
Entonces vuelvo a decir 00:22:08
Este 00:22:09
Que es el contenido 00:22:10
Si me voy a 00:22:12
Utilización de la CPU 00:22:15
Es el título 00:22:17
Si me voy al OK 00:22:19
Es el botón que quiero que me aparezca 00:22:22
Y luego el icono 00:22:24
Que es el warning 00:22:29
Que es este que tenéis aquí 00:22:30
Que es el warning 00:22:32
¿De acuerdo? 00:22:34
Pues esto es lo que quiero que se me ejecute 00:22:36
Entonces vamos a hacerlo 00:22:38
¿De acuerdo? 00:22:39
Simplemente para que me entendáis que es lo que hace 00:22:40
Entonces, ¿qué es lo que voy a ejecutar yo? 00:22:42
en el comando 00:22:45
esto lo voy a quitar 00:22:47
esto lo minimizo 00:22:49
¿qué es lo que voy a poner aquí? 00:22:52
yo el programa que quiero ejecutar 00:22:54
realmente es el PowerShell 00:22:55
y yo al PowerShell 00:22:58
los argumentos que le quiero pasar 00:23:00
es esos dos comandos que quiero que me ejecute 00:23:02
no sé si me entendéis 00:23:05
entonces ¿cómo lo voy a hacer? 00:23:06
pues lo que voy a hacer es pasarle esta ventana 00:23:09
os lo voy a escribir aquí 00:23:13
¿para qué? porque se ve mejor 00:23:14
Y ahora es lo que vamos a poner, ¿vale? Esto es lo que le pongo. Es decir, los argumentos que le voy a pasar al PowerShell va a ser, oye, quiero que cuando ejecutes el PowerShell la ventana me aparezca oculta y quiero que me ejecutes el comando y ahora entre comillas tengo que poner el comando que quiero que me ejecute, ¿vale? 00:23:15
Este ampersand es porque quiero que me trate todo como una cadena de texto 00:23:37
Que es lo que quiero que me ejecute, ¿de acuerdo? 00:23:42
Por eso pongo el ampersand 00:23:44
Si no os ponéis el ampersand os va a salir un error y no se va a ejecutar, ¿de acuerdo? 00:23:45
Entonces, ¿qué es lo que quiero que me ejecute? 00:23:49
Pues fijaros que entre llaves le pongo todo lo que quiero que me ejecute 00:23:51
Cada comando que queréis que ejecute y que represente una línea lo vais a separar por punto y coma 00:23:56
Me explico 00:24:01
Yo voy a coger primero el comando que me va a permitir importar las clases para poder utilizar el método show 00:24:03
Luego le pongo el punto y coma para decirle que voy a poner otro comando 00:24:15
Y luego le pongo el comando que hemos visto antes 00:24:20
¿Sí? 00:24:23
Entonces, este comando me he equivocado y tengo que poner aquí el texto, ¿vale? 00:24:25
Lo voy a cambiar ahora 00:24:29
¿De acuerdo? 00:24:30
Porque este es el siguiente ejemplo que vamos a hacer 00:24:31
Pues esto es lo que le voy a pasar como argumento 00:24:33
¿Vale? Pues lo vamos a ver 00:24:35
Minimizamos esto 00:24:36
Y ahora donde pone argumentos 00:24:39
Pues vamos a copiar 00:24:41
Vamos a pegar, perdón 00:24:43
Pues todo lo que hemos dicho 00:24:45
¿Vale? 00:24:46
El Windows style hidden 00:24:47
Pa pa pa, pa pa pa 00:24:49
Con todo lo que hemos visto 00:24:50
¿De acuerdo? 00:24:51
Es decir, los dos comandos en una sola línea 00:24:52
¿De acuerdo? 00:24:53
Le damos a siguiente 00:24:55
Le decimos finalizar 00:24:56
me dice el visor de eventos, creo la tarea programada 00:24:59
bla bla bla, para realizar 00:25:02
modificaciones, abre el programa de tareas 00:25:03
pues vamos a ver donde me ha guardado esto 00:25:06
si abrimos el programador de tareas 00:25:07
me voy a inicio 00:25:10
y pongo aquí, programador 00:25:11
tareas 00:25:14
pues vamos a ver donde me la ha creado 00:25:14
pues donde me la ha creado 00:25:18
si pincho aquí 00:25:22
donde pone bibliotecas 00:25:23
aquí yo no sé 00:25:26
si llegáis a ver 00:25:28
que tengo, perdonadme 00:25:28
que tengo Microsoft y luego tengo 00:25:31
tareas del visor de eventos 00:25:33
si yo pincho en tareas del visor 00:25:34
de eventos, pues yo no sé si llegáis a ver 00:25:37
que aquí me ha generado 00:25:39
me ha generado la tarea 00:25:41
correspondiente, vale 00:25:43
la tengo aquí 00:25:44
yo puedo editarla 00:25:47
le puedo decir botón derecho 00:25:49
le puedo decir propiedades 00:25:51
y aquí lo que hemos hecho antes 00:25:52
nosotros aquí 00:25:55
el nombre que hemos puesto en desencadenadores le hemos dicho que esto se va a generar cuando 00:25:56
se produzca un evento si le doy a editar pues fijaros que aquí le hemos dicho que cuando se 00:26:03
ejecute dentro del registro plat originado por este de aquí con el identificador 2031 que hemos 00:26:16
puesto de acuerdo dentro del registro y se va a producir cuando se produzca ese evento y vale y 00:26:25
qué es lo que quiero que me ejecute pues si me voy a acciones pues fijaros que aquí tenemos el 00:26:33
comando que me va a ejecutar me va a abrir power cell pasándole los argumentos que le hemos visto 00:26:37
de acuerdo vale pues vamos a ver si esto me funciona voy a minimizar esto todavía lo tengo 00:26:42
arrancado vale pues mira lo voy a dejar como está arrancado no tengo que hacer nada 00:26:49
Vamos a forzarlo, a ver qué pasa. Le doy aquí al Start, entonces se me va a poner el procesador al 100%, entonces cuando pasen 3 segundos, ¡pum! Yo no sé si lo veis. Esto lo voy a parar ya. 00:26:55
entonces, yo no sé si veis 00:27:09
esto lo dejo preparado 00:27:13
que se me ha generado aquí la ventanita 00:27:15
utilización de la CPU 00:27:17
es decir, ¿qué es lo que ha hecho? cuando se ha generado 00:27:18
el evento, ese evento 00:27:21
ha generado que se realice, que se ejecute 00:27:23
una tarea programada 00:27:25
pues imaginaros que en lugar de hacer esta tontería 00:27:26
que he hecho, pues le podéis decir que escriba 00:27:29
un correo al administrador, le podéis decir que haga 00:27:31
una copia de seguridad, le podéis decir que coja 00:27:33
yo que sé, el proceso que más 00:27:36
están consumiendo y que se quede reflejado 00:27:37
dentro de un ficherito de log, o sea, podéis hacer prácticamente lo que os dé 00:27:40
la real gana, ¿de acuerdo? Esto sería por una parte 00:27:44
yo lo que voy a hacer es, para que podamos seguir 00:27:47
haciendo ejemplos, voy a irme al 00:27:49
programador de tareas y vamos a borrar esta tarea, ¿de acuerdo? 00:27:52
porque esta es una opción que tenéis, luego vemos otra, entonces botón derecho 00:27:55
le digo eliminar la tarea correspondiente 00:27:58
¿vale? porque esto ya hemos visto 00:28:02
cómo se hace, así que vamos a hacer otro ejemplo y le digo que sí 00:28:04
porque si no va a estar saltando cada vez que hagamos un ejemplo va a estar saltando esa 00:28:07
ventanita y no me apetece vale pues que lo que vamos a hacer ahora ya hemos visto cómo se puede 00:28:13
quedar reflejado en el visor de eventos porque os recuerdo que aquí en el visor de eventos vale si 00:28:18
le doy a actualizar pues todo el rato me está diciendo que se ha generado esa alerta correspondiente 00:28:24
de acuerdo que lo tengo aquí que lo tenéis aquí y hago doble clic lo ven mucho mejor de acuerdo y 00:28:29
si voy bajando pues va viendo pues todas las alertas que se han ido generando si este lo voy 00:28:36
a volver a vaciar para que podamos seguir haciendo el ejercicio y ahora lo que vamos a hacer es vale 00:28:43
hemos visto ahora sí lo voy a parar porque lo voy a modificar le doy al stop vamos a otra vez 00:28:52
modificarlo y le voy a decir dentro de acción de alerta que no solamente quiero que me quede 00:28:58
registrado en el visor de eventos sino que además que cuando salte esta alerta quiero 00:29:03
que automáticamente se ejecute este contador de rendimiento entonces este es el que hicimos en 00:29:09
el vídeo anterior pues le voy a decir que va a durar 30 segundos le voy a decir que cuando 00:29:15
la alerta se genere pues automáticamente se ejecute este contador de acuerdo le damos a 00:29:21
aceptar le damos aquí al play y vamos a poner el procesador a 100% entonces me voy aquí le damos al 00:29:28
start entonces quiero que veáis qué va a pasar en nada en contador veis que se está ejecutando 00:29:39
contador voy a darle ya aquí al stop ahora que no está generando entonces fijaros que cuánto me va 00:29:46
dura el contador pues le hemos puesto 30 segundos entonces esto va a estar ejecutándose 30 segundos 00:29:54
y me ha generado esa alerta de contador entonces repito le hemos dicho que cuando se genere la 00:29:59
alerta correspondiente a la cpu que nosotros tenemos pues que automáticamente lance que 00:30:06
ejecute el contador que nosotros hemos puesto ese contador que hemos puesto que hicimos el otro día 00:30:10
no sigue para ahora pero fijaros que ya ha terminado entonces si yo me voy aquí pues tendré 00:30:15
este contador que me ha generado 00:30:19
y automáticamente me lo ha ejecutado 00:30:22
cuando se ha producido la alerta 00:30:24
¿qué ha pasado en el visor de eventos? 00:30:26
pues si nos vamos al visor de eventos 00:30:28
le voy a dar aquí a actualizar 00:30:29
y quiero que veáis que aquí me salen 00:30:32
unos errores, ¿vale? 00:30:34
esto no os preocupéis porque me dice 00:30:36
oye, voy a abrir uno de ellos 00:30:38
porque fijaros que 00:30:39
abro este de aquí 00:30:41
este de aquí 00:30:43
que me dice que ha superado el umbral 00:30:46
que correspondería a este de aquí 00:30:48
¿vale? pero si yo sigo para arriba 00:30:50
me muestra un error 00:30:53
y me dice error de la recopilación de datos 00:30:54
del data collector 1 00:30:56
del conjunto de recopiladores de datos 00:30:58
alerta CPU al iniciar un conjunto 00:31:00
de recopiladores de datos 00:31:02
¿esto por qué? porque fijaros que 00:31:04
la primera vez que se ha superado 00:31:06
el contador 00:31:08
ha lanzado 00:31:11
este de aquí, el contador 01 00:31:12
pero como cada 3 segundos 00:31:14
se vuelve a generar la alerta 00:31:16
me vuelva a lanzar el contador 00:31:18
01, pero como ya está arrancado 00:31:19
me dice un error porque ya está arrancado, ¿vale? 00:31:21
así que eso es normal, tenemos que saber 00:31:23
leer los errores que nos da, ¿de acuerdo? 00:31:25
entonces esto me está diciendo, oye, ya 00:31:27
está arrancado el contador 01 00:31:29
no lo puedo volver a arrancar, eso simplemente 00:31:31
me está diciendo, pero fijaros que no funciona perfectamente 00:31:33
entonces ya tenemos la siguiente 00:31:36
opción, le voy a dar a parar 00:31:37
y ya le hemos visto aquí 00:31:39
que aquí en propiedades, en alertación 00:31:41
hemos visto para qué sirve tanto 00:31:44
el primero, el de 00:31:45
de alerta, yo este siempre lo tendría marcado 00:31:47
la verdad, y luego si quiero que se me 00:31:49
ejecute un conjunto de recopiladores 00:31:51
de datos, aquí para poder hacer 00:31:53
el siguiente ejemplo, si que no se me está 00:31:55
ejecutando mal, lo voy a quitar 00:31:57
y ahora me queda la tarea 00:31:58
de alerta, yo aquí le puedo 00:32:01
decir que se me ejecute 00:32:03
perdón, yo le puedo decir aquí que se me ejecute 00:32:05
una tarea cuando 00:32:08
se haya 00:32:09
generado la alerta, entonces 00:32:11
aquí lo que tengo que hacer es previamente 00:32:13
haber generado la tarea programada 00:32:15
dentro del programador de tareas 00:32:18
entonces aquí vamos a hacer 00:32:19
dos ejemplos, por ejemplo 00:32:21
vamos a poner aquí 00:32:23
todos los valores, yo me voy a ir 00:32:25
al programador de tareas 00:32:27
y vamos a generar dos tareas 00:32:29
programadas, me voy a la biblioteca 00:32:31
¿vale? si no me estáis siguiendo 00:32:33
he pinchado aquí en biblioteca 00:32:35
y vamos a crear aquí dos tareas 00:32:37
¿vale? las dos van a hacer lo mismo 00:32:39
pero con una pequeña sutileza 00:32:41
van a mostrar 00:32:43
el mensaje que hemos visto antes 00:32:44
¿de acuerdo? entonces el primero 00:32:47
ya sabemos de que va, entonces le digo botón derecho 00:32:49
le digo crear nueva 00:32:51
tarea 00:32:53
este de aquí 00:32:54
le ponemos un nombre, por ejemplo 00:32:57
se va a llamar 00:33:01
mensaje 001 00:33:02
aquí los valores 00:33:06
ya si me da tiempo veremos 00:33:08
como se hace una tarea programada, es una chorrada 00:33:09
le digo desencadenadores 00:33:11
aquí no digo nada, porque lo voy a ejecutar 00:33:14
yo cuando yo diga 00:33:16
en acciones sí que le voy a decir que quiero 00:33:18
que me ejecute un comando 00:33:20
entonces pincho donde me pone nueva 00:33:21
el programa, le digo que quiero ejecutar un programa 00:33:24
le digo que el programa se llama 00:33:30
powershell 00:33:32
¿sí? y ahora aquí la única 00:33:33
diferencia con antes 00:33:38
Entonces el comando que he escrito antes que os he dicho que estaba mal, os lo muestro aquí. Yo no sé si os acordáis de que aquí había esto. ¿Y esto qué es? Pues resulta que yo a una tarea programada le puedo pasar argumentos desde otro sitio. 00:33:41
entonces, ¿cómo lo hago? pues esto que estáis viendo 00:34:01
aquí, me voy 00:34:04
es lo que voy a poner exactamente 00:34:06
en la tarea programada 00:34:08
entonces voy a poner como argumento 00:34:09
todo eso, ¿de acuerdo? 00:34:11
es decir, le pongo que 00:34:14
la ventana se oculte, o sea que aparezca 00:34:16
la de power se lo oculta y que me aparezca el mensajito 00:34:18
pero le estoy diciendo 00:34:20
¿vale? le digo ok 00:34:22
y lo demás lo dejo tal cual, le digo aceptar 00:34:24
y ya tengo el mensaje 01 00:34:26
como yo tengo 00:34:28
una tarea programada que se llama mensaje 01 nos vamos a ir al monitor de rendimiento le voy a 00:34:30
decir botón derecho propiedades y en la tarea voy a poner aquí mensaje 001 se llama mensaje 001 00:34:38
perfecto y ahora como argumentos vamos a hacer una cosa para que veáis qué consiste cada argumento 00:34:52
voy a poner aquí 00:34:58
todos, para que veamos 00:35:00
qué quiere decir cada uno de ellos, vamos a ver 00:35:03
qué quiere decir el name, el date, el counter 00:35:05
el three holes, value 00:35:07
y user test 00:35:09
si yo selecciono el name, ves que me lo 00:35:10
escribe, entonces yo puedo poner aquí 00:35:13
lo que me la gana, es el 00:35:15
y yo voy poniendo aquí 00:35:17
todo lo que quiera, y le digo date 00:35:19
pero como yo quiero 00:35:20
pasárselo 00:35:23
a una 00:35:25
tarea programada 00:35:25
Pues lo que vamos a hacer es lo siguiente 00:35:28
Voy a poner todos escritos 00:35:30
Pero ya, dejarme que lo escriba directamente 00:35:31
Y lo voy a poner así 00:35:33
Es decir, he escrito todos los que tenéis aquí 00:35:35
Lo que pasa es que lo he puesto todos 00:35:41
Separados por un espacio en blanco 00:35:43
Y entre comillas dobles 00:35:45
¿Vale? 00:35:47
¿Y esto por qué lo hago? Pues ahora os lo comento 00:35:48
¿Vale? He puesto el name entre comillas dobles 00:35:50
He dejado un espacio 00:35:53
Date, comillas dobles 00:35:54
he dejado un espacio, counter 00:35:56
comillas dobles, he dejado un espacio 00:35:58
y así con todos, porque quiero que veáis 00:36:00
y como resulta que he puesto 00:36:03
el user test 00:36:05
pues en el user test 00:36:07
se me va a traducir por lo que yo escriba 00:36:09
aquí abajo, pues yo aquí 00:36:11
voy a poner, pues yo que sé 00:36:13
pues esto de aquí, de 00:36:15
que no tengo ganas de escribir 00:36:16
¿de acuerdo? entonces quiero que veáis 00:36:18
que conforme a lo que yo he escrito 00:36:21
aquí arriba 00:36:23
Y aquí, pues aquí me pone 00:36:24
Qué es lo que se va a enviar 00:36:28
¿Vale? 00:36:31
Entonces, yo no sé si llegáis a ver 00:36:32
Que cuando yo he puesto aquí el name 00:36:34
Pues se me va a convertir en 00:36:37
Alerta CPU Data Collector 00:36:39
Que si yo pongo aquí el date 00:36:41
Pues lo que me va a enviar en este caso es 00:36:44
Uy, perdóname 00:36:47
Es en este caso la fecha 00:36:48
¿Sí? 00:36:51
Que si yo le pongo aquí el counter, es decir, el contador de rendimiento que estamos midiendo 00:36:51
Pues se me va a traducir en el tanto por ciento del CPU 00:36:58
Y así con cada uno de ellos 00:37:02
Pues ahora vamos a ir viéndolo 00:37:03
Entonces, repito, cuando se ejecute esta alerta, ¿qué es lo que va a hacer? 00:37:05
Pues lo que va a hacer es, va a ejecutar esta tarea programada 00:37:10
Y le va a enviar todos estos argumentos 00:37:13
Y resulta que estos argumentos se van a enviar 00:37:16
lo va a recibir la tarea programada 00:37:19
de la siguiente manera 00:37:23
dejadme que ponga esto más 00:37:24
porque quiero que veáis una cosa 00:37:26
vale 00:37:41
aquí en botón derecho 00:37:42
en propiedades 00:37:43
en tareas 00:37:44
entonces quiero que entendáis 00:37:45
que a la tarea programada le voy a enviar todo esto que todo esto repito se va a traducir en 00:37:48
esto que tengo aquí entonces como el envío todo esto a la tarea programada pues fijaros que con 00:37:54
este argumento tengo que poner tanto por ciento y entre paréntesis a rg entonces todo esto que 00:38:00
estáis viendo aquí en el cuadradito se lo voy a pasar a la tarea de esa manera de acuerdo dentro 00:38:09
de dólar y entre paréntesis 00:38:13
ARG 0 00:38:16
de acuerdo 00:38:17
entonces le doy a aceptar, ya tenemos aquí 00:38:19
la herramienta, pues vamos a ver 00:38:21
si esto nos funciona, porque repito 00:38:23
que le hemos dicho que cuando 00:38:25
se genere, me ejecute 00:38:27
mensaje 01, pues lo vamos a ejecutar 00:38:30
selecciono alerta CPU 00:38:32
le doy aquí al play 00:38:33
y ponemos al procesador al 100% 00:38:34
Le damos a Start y lo paro, porque ya ha salido lo que quiero. 00:38:43
Yo no sé si habéis visto el mensajito, vamos a ver el mensajito que me ha dado. 00:38:56
Este mensajito lo voy a poner por aquí, voy a parar la alerta y vamos a ver las propiedades. 00:39:05
a ver que lo pongo así 00:39:13
porque quiero que veáis todo 00:39:15
me voy a propiedades 00:39:16
y ahí aquí tengo 00:39:19
todos, entonces ¿qué es lo que 00:39:21
ha hecho esto? pues fijaros 00:39:23
yo le he pasado todos estos valores 00:39:25
¿sí? pues esto que me pone 00:39:27
name, lo que le ha 00:39:29
pasado aquí es esto que me pone 00:39:31
alerta CPU data collection 00:39:34
esto es el name 00:39:35
¿de acuerdo? 00:39:36
es decir, ves que 00:39:39
alerta collection que me pone el nombre 00:39:41
pues obviamente es alerta cpu 00:39:43
junto con el data collection 00:39:46
esto bien ¿no? 00:39:50
me voy al siguiente, me voy a fecha 00:39:51
me dice la fecha es cuando 00:39:53
se ha generado la alerta 00:39:55
¿qué es lo que me ha enviado? pues lo que me ha enviado es 00:39:57
esto que veis aquí 00:39:59
¿qué es esto que veis aquí? 00:40:00
¿de acuerdo? es decir cuando se ha producido la alerta 00:40:03
pues la verdad es que es útil para saber exactamente 00:40:05
cuando se ha producido 00:40:07
me voy al siguiente, el counter 00:40:08
El counter se refiere a cuál es el contador que se ha superado 00:40:10
Pues el counter que se ha superado es este que os pongo aquí 00:40:16
De procesador, tanto por ciento total de tiempo del procesador 00:40:20
¿Me seguís? 00:40:24
Me voy al siguiente, me voy al 3 holes 00:40:26
¿Y este qué es? 00:40:29
Pues este es el valor del umbral que nosotros hemos puesto 00:40:32
Pues este sería correspondiente al mayor de 96 00:40:35
es decir, esto que le ha pasado 00:40:39
vais viendo 00:40:42
todos separados por espacios 00:40:44
luego me queda, por último 00:40:45
me queda el value 00:40:48
y el value es 00:40:49
el valor actual 00:40:51
cuando se ha 00:40:53
producido la alerta del procesador 00:40:56
en este caso, porque me ha puesto CPU 00:40:58
así que a mí me están poniendo que el CPU 00:40:59
está al 100%, el valor 00:41:02
actual que ha producido la alerta 00:41:04
y por último 00:41:06
el user test, y en el user test 00:41:07
pues fijaros que como yo 00:41:10
le he dicho que quiero escribir este texto 00:41:11
pues que es lo que me ha puesto 00:41:13
pues me ha puesto el texto que yo le he dicho 00:41:15
que me ponga, tonterías 00:41:17
de acuerdo 00:41:19
entonces hasta aquí bien, pero veis que el 00:41:20
$args0 me ha devuelto 00:41:23
todo eso, como si fuese 00:41:26
solamente un argumento 00:41:27
que pasa si yo quiero personalizar la tarea 00:41:29
pues es la segunda que vamos a ver, de acuerdo 00:41:31
entonces aquí 00:41:33
lo dejamos exactamente igual 00:41:35
y ahora vamos a hacer una segunda tarea 00:41:37
le damos a aceptar, porque aquí no tenemos que tocar nada 00:41:39
por ahora 00:41:42
y vamos a crear antes de nada 00:41:43
nuestro ficherito 00:41:46
PowerShell Script 00:41:47
entonces nos vamos ahí al explorador 00:41:50
y por ejemplo 00:41:52
aquí en E 00:41:54
yo he creado este ficherito 00:41:55
entonces voy a editarlo 00:41:58
lo he creado para no perder tiempo 00:42:00
es un ficherito de texto 00:42:02
botón derecho 00:42:03
editar, me va a abrir 00:42:05
el PowerShell IC 00:42:08
el entorno de desarrollo de PowerShell 00:42:10
¿vale? veis que es un ficherito de texto 00:42:12
entonces, ¿qué es lo que quiero 00:42:18
que veáis aquí? digo, pues vamos a ver 00:42:20
¿qué contiene este ficherito de texto? 00:42:22
simplemente contiene líneas 00:42:24
con comandos que yo quiero que me ejecute 00:42:26
entonces tiene que tener extensión 00:42:28
PS1, ¿de acuerdo? entonces, primera línea 00:42:30
pues 00:42:32
veis aquí que la primera línea es la misma 00:42:34
que teníamos antes, es decir, oye 00:42:36
voy a coger estas clases para que 00:42:38
yo pueda trabajar con el mensajito 00:42:40
¿sí? y ahora me 00:42:42
dice, oye, y la última línea lo que 00:42:44
hace es coger el show, ¿qué es lo que 00:42:46
hacen las cuatro líneas restantes? pues crearme 00:42:48
variables, por ejemplo 00:42:50
esta variable 00:42:52
que contiene simplemente en warning 00:42:54
que fijaros que 00:42:56
es el 00:42:58
icono que me va a mostrar, ¿de acuerdo? 00:43:00
es decir 00:43:03
simplemente estoy cogiendo 00:43:03
variables, la variable 00:43:06
botón mensa 00:43:08
que le he puesto ok, para que me aparezca el botón 00:43:09
ok, que simplemente es 00:43:12
que se lo he pasado al botón mensa 00:43:14
es decir, estos son chorradas 00:43:16
me voy al título 00:43:18
que en el título 00:43:19
es título mensa 00:43:21
y fijaros que le he puesto 00:43:24
args 00:43:25
0, que no es 00:43:28
lo mismo que antes, quiero que 00:43:30
entendáis. Lo voy a poner así para que lo veáis, a ver si lo puedo ver. Lo voy a poner así. Fijaros que antes le hemos pasado aquí entre dólar y entre paréntesis ARG0. Pues aquí no, dentro de PowerShell es dólar ARGS y ahora entre corchetes la posición del argumento que 00:43:32
quiero mostrar me explico voy a abrir el power cell perdón el monitor de rendimiento voy a 00:44:02
abrir aquí voy perdonarme botón derecho botón derecho propiedades 00:44:09
y quiero que veáis que aquí en tareas cuando yo le pase esto el nombre este de aquí este 00:44:21
corresponde al argumento 0. ¿Me seguís? Por eso lo he puesto entre comillas, porque si el nombre 00:44:31
contiene espacios, como está entre comillas, lo va a considerar como un solo argumento. En cambio, 00:44:42
si yo pongo los espacio lunes, los sería el argumento 0 y lunes sería el argumento 1. Entonces, 00:44:47
por eso lo pongo entre comillas dobles entonces este va a ser el argumento 0 el de hoy perdón 00:44:54
el de va a ser el argumento 1 el counter el 2 el frijol el 3 el value el 4 y el user 3 el 5 00:45:01
¿Vale? Entonces fijaros que lo voy a poner así para que lo veáis y este lo muestro mal. 00:45:13
Entonces, quiero que veáis que el argumento 0, ¿vale? Repito, sería este de aquí, del argumento 0, ¿sí? 00:45:37
Entonces, ¿qué es lo que me queda? Me queda que veáis que el contenido del mensaje, estoy haciendo un mensaje personalizado. 00:45:51
Entonces, yo quiero poner el contador, por eso lo he puesto entre comillas simple o entre comillas doble, me da igual, ¿de acuerdo? 00:45:58
¿Para qué es el más? Para concatenar cadenas. Entonces quiero que veáis que este de más es para concatenar el texto que hay antes con el contenido del argumento 0. Le vuelvo a poner más, concatenar, concatenar, es decir, unir cadenas de caracteres, unir, unir, unir, ¿vale? 00:46:04
Entonces, ¿qué es lo que hace esto? Me pone, oye, el contador. Luego me añade el contenido del argumento cero. ¿Cuál es el contenido del argumento cero? Pues el name. 00:46:24
Luego me pone a fecha 00:46:36
Luego me pone el contenido del argumento 1 00:46:39
¿Y cuál es el contenido del argumento 1? 00:46:42
Pues en este caso, date 00:46:45
Luego me pone, se ha superado 00:46:46
Y luego me pone el dólar ARK posición 2 00:46:50
¿Y este cuál va a ser? 00:46:55
Pues en este caso, el counter 00:46:56
Me va siguiendo 00:46:58
Es decir, estoy haciendo un mensaje personalizado 00:46:59
Luego voy a poner el 3 00:47:02
luego voy a poner el 4 y luego voy a poner el 5 00:47:04
entonces si me voy aquí 00:47:07
esto ya lo puedo cerrar 00:47:09
si me voy aquí 00:47:10
pues quiero que veáis 00:47:13
que estamos por aquí, se ha superado 00:47:14
con el valor tanto por 104 00:47:17
¿de acuerdo? cuando el umbral se ha superado 00:47:19
entonces lo pongo otra vez por aquí 00:47:23
porque quiero que quede claro 00:47:25
que no lo tenía que haber cerrado 00:47:27
entonces estoy aquí 00:47:29
entonces le digo con el valor 00:47:36
y le digo el argumento 4 00:47:39
que el argumento 4 sería 00:47:41
el guión value 00:47:43
es decir, sería este de aquí, el value 00:47:46
cuando el umbral está en 00:47:49
le pongo la cadena cuando el umbral está en 00:47:52
y le pongo el contenido del argumento 3 00:47:56
¿Y el argumento 3 cuál va a ser? Pues el argumento 3 va a ser el mayor de 96. 00:47:58
¿Vais viendo? Y luego al final que me quedaría el 0, 1, 2, 3, 4, el argumento 5. 00:48:05
Y el argumento 5 pues me pone el texto, ¿vale? Que le he puesto aquí del argumento 5. 00:48:11
Pues este sería el que hemos puesto aquí, ¿de acuerdo? Del user test. 00:48:18
¿sí? entonces por eso lo ponemos 00:48:27
entre comillas doble, repito 00:48:30
vamos a ver si no funciona 00:48:31
entonces ya tenemos este script 00:48:33
yo quiero hacer una tarea programada 00:48:38
que lo que haga es llamar 00:48:40
a este script 00:48:41
¿de acuerdo? entonces repito 00:48:44
esto es como hacer un fichero de texto 00:48:46
le pongo extensión ps1 y lo que hago es 00:48:48
copiar lo que tenemos aquí 00:48:50
¿sí? ¿de acuerdo? 00:48:51
vale, una vez que ya tenemos 00:48:55
este, lo cierro y creamos 00:48:56
la tarea programada, podemos 00:48:58
crear la tarea programada 00:49:00
entonces nos vamos a la tarea 00:49:01
programada y a esta tarea le vamos a 00:49:04
crear una nueva tarea y le vamos a llamar 00:49:06
mensaje 002 00:49:08
desencadenadores no quiero 00:49:10
nada porque lo voy a ejecutar cuando a mi me da la gana 00:49:14
y en acciones le digo nueva 00:49:16
porque queremos decir 00:49:18
que queremos llamar al powershell como antes 00:49:20
entonces le digo nueva, le pongo aquí 00:49:22
powershell 00:49:24
y como argumentos 00:49:25
le vamos a pasar lo siguiente 00:49:28
voy a abrir 00:49:31
para escribirlo aquí 00:49:35
y lo pongo más grande 00:49:42
¿vale? entonces quiero que veáis 00:49:44
que el argumento que le voy a pasar 00:49:46
es igual que antes, le digo 00:49:48
quiero que me ejecute PowerShell 00:49:50
en modo de ventana oculto 00:49:51
Pero ahora, en lugar de decirle aquí guión comand, ¿vale? Porque no sé si recordáis que antes, os lo pongo aquí para recordar que lo que era, antes el argumento que le habíamos pasado era este de aquí, ¿vale? 00:49:53
Que le decíamos, oye, quiero que me ejecutes un comando 00:50:07
¿Y qué comando quiero que me ejecutes? 00:50:10
Pues todo este chorro de aquí, ¿de acuerdo? 00:50:12
Que os dije que esto es para que lo represente como una cadena 00:50:14
Para que se me ejecute bien 00:50:17
Y entre llaves, los comandos que quiero ejecutar 00:50:18
Cada comando separado por punto y coma 00:50:22
Pues ahora no quiero ejecutar un comando 00:50:23
Ahora lo que quiero ejecutar es un fichero 00:50:25
Entonces le digo guión file, ¿de acuerdo? 00:50:27
Aquí lo he copiado mal, pero bueno 00:50:30
Le tengo que decir la ruta del fichero que quiero que me ejecute 00:50:31
¿Vale? Que yo en mi caso se llama mostrar ventana. ¿Y qué le voy a pasar como argumento? Pues igual que antes, el dólar abre y cierra paréntesis arg0. ¿De acuerdo? Esto de aquí, no sé por qué, pero lo he puesto en las comillas estas, que serían estas de aquí. ¿De acuerdo? Vamos a hacerlo. 00:50:35
entonces me voy aquí a las opciones 00:50:57
y le voy a decir que quiero que me ejecute esto 00:51:00
entonces le paso como argumento lo que hemos dicho 00:51:04
el ar 0, le doy a aceptar 00:51:08
le doy a aceptar 00:51:10
y ahora lo único que tengo que hacer en el monitor rendimiento 00:51:12
es que quiero que me ejecute el mensaje 002 00:51:15
pues nos vamos a la recta, botón derecho, propiedades 00:51:18
y aquí en lugar de 01 pongo el 02 00:51:22
¿de acuerdo? 00:51:26
lo único que he cambiado es 00:51:27
que la tarea que se va a ejecutar no es 00:51:30
el mensaje 0 de 1, sino el mensaje 00:51:32
0 de 2, todo esto lo he dejado igual 00:51:34
para que veáis, todo esto lo he dejado igual 00:51:36
pues vamos a ver que nos muestra 00:51:37
le digo aceptar 00:51:39
la ejecuto 00:51:41
someto al procesador al 100% 00:51:43
espero 3 segundos y me tiene que saltar la alarma 00:51:46
y aquí no me ha saltado 00:51:52
me está saltando pero no me está mostrando un mensajito 00:51:56
porque tiene que haber un error 00:51:58
la voy a parar 00:52:00
y voy a mirar 00:52:01
vale, que estaba mirando porque no me salía 00:52:05
y resulta que lo tengo que poner 00:52:09
sin 00:52:11
comillas, ¿de acuerdo? entonces tenemos que 00:52:11
ejecutar este comando tal cual 00:52:14
entonces vamos 00:52:16
a editar la tarea 00:52:18
que la he escrito mal, mensaje 00:52:19
0d02, botón derecho 00:52:22
propiedades 00:52:24
acciones 00:52:25
lo selecciono 00:52:27
editar 00:52:29
y en los argumentos 00:52:30
vamos a pegarlo bien 00:52:32
le doy a aceptar 00:52:34
y vamos a someter 00:52:36
como todavía se me está ejecutando la alerta 00:52:39
pues vamos a someter al procesador al 100% 00:52:42
a ver si nos tira 00:52:45
le damos a start 00:52:46
esperamos 3 segundos 00:52:47
y veis que se me ha generado la alerta 00:52:48
voy a pararlo 00:52:54
minimizo esto 00:52:55
y vamos a ver que me ha salido aquí 00:53:00
me ha salido el mensajito 00:53:02
me da aquí las propiedades 00:53:04
de la tarea 00:53:06
de la alerta y además 00:53:07
voy a coger el mensajito 02 00:53:10
el mensajito 02 00:53:12
no, perdonadme 00:53:14
y el PowerShell 00:53:15
aquí, cogemos el ventanito 00:53:17
botón derecho, editar 00:53:22
Vale, esto voy a hacer lo siguiente 00:53:24
Me pongo aquí el intro para que lo veáis todo de un vistazo 00:53:30
¿De acuerdo? Entonces vamos a ver que me ha hecho esto 00:53:35
Si me voy aquí 00:53:38
¿Vale? Fijaros que me ha generado el mensajito correspondiente 00:53:42
Me pone, oye, el contador 00:53:48
Pues muy bien, el contador 00:53:51
y me pone argumento 0 00:53:53
y el argumento 0 hemos dicho 00:53:55
que es este de aquí, que es el name 00:53:57
y entonces, ¿qué es lo que me ha dicho 00:54:00
con el name? pues lo que me ha puesto 00:54:02
aquí, lo pongo en, yo que sé 00:54:04
en green, me dice 00:54:08
alerta CPU data 01 00:54:09
¿sí? 00:54:12
luego me pone, ya no pongo nada porque si no 00:54:14
va a ser muchas flechitas, me pone a fecha 00:54:15
y me pone argumento 01 00:54:18
pues argumento 01 lo tenemos 00:54:19
aquí, luego me dice 00:54:21
se ha superado, se ha superado 00:54:24
y me pone el procesador 00:54:25
tanto por ciento de tiempo de procesador 00:54:28
luego me pone 00:54:30
con valor, me pone el argumento 00:54:32
4, que es 00:54:33
el 100%, cuando 00:54:35
el umbral está en 00:54:37
más 96% 00:54:39
y me pone que sepas que 00:54:41
y te has pasado 3 pueblos 00:54:43
entonces pongo en rojo 00:54:45
perdón 00:54:47
pongo en rojo lo que me pone aquí 00:54:49
Dice, se ha superado, perdonadme, se ha superado, es decir, me pone el texto y luego me va concatenando cada uno de los argumentos, que si la fecha, que si el contador que me está teniendo, que si el umbral, que si el valor actual o que si el contenido del rayatez, ¿de acuerdo? 00:54:51
Entonces, son diferentes maneras en las que yo puedo gestionar y mandar argumentos desde una alerta de rendimiento a una tarea programada, ¿de acuerdo? Entonces, aquí ya podéis hacer lo que os dé la gana. 00:55:12
Repito, yo este ejemplo que he hecho es como una ventana de mierda 00:55:25
¿Vale? Que me aparece aquí un texto 00:55:28
Pero podéis hacer cualquier tarea que os dé la real gana 00:55:30
¿De acuerdo? 00:55:33
Y como no, esto se me queda reflejado 00:55:34
Dentro del visor de eventos 00:55:37
Si yo me voy aquí al visor de eventos 00:55:39
Pues aquí en todo momento, si yo refresco 00:55:41
Le doy a actualizar 00:55:43
Pues aquí me va poniendo todo lo que ha pasado 00:55:44
¿De acuerdo? Cuando se ha superado, cuando no se ha superado 00:55:47
¿De acuerdo? Dentro de 00:55:50
Diagnosis 00:55:51
Guión Pla 00:55:53
¿de acuerdo? pues con esto ya tendríamos todas las opciones que yo puedo tener al crear una alerta 00:55:54
la voy a parar, la alerta, ¿vale? pero ya hemos visto dentro de propiedades 00:56:00
hemos visto las alertas que puedo poner, cada cuánto tiempo quiero que me la ponga 00:56:06
el umbral que asigno a cada una de ellas 00:56:12
luego le hemos dicho que la puedo poner o dentro del visor de eventos 00:56:14
o que cuando se genere llame a un conjunto de recopiladores de datos que ya tengo establecido 00:56:20
o que cuando se ejecute, que se me ejecute una tarea que yo ya he definido 00:56:25
o lo hago desde aquí pasándole los argumentos que me dé la gana, de acuerdo, incluso el texto 00:56:31
o yo puedo ir al visor de eventos, me voy aquí a cancelar 00:56:36
y hemos visto que dentro del visor de eventos selecciono el evento que se ha producido 00:56:40
En este caso es el 2031, botón derecho y le digo a juntar tarea a este evento, ¿de acuerdo? 00:56:46
Entonces con esto ya tendríamos una visión un poco general de cómo podemos crear cualquier tipo de alerta, ¿de acuerdo? 00:56:53
Yo creo que es bastante interesante, ¿de acuerdo? 00:56:59
¿Qué es lo que nos quedaría hacer? 00:57:02
Y ya con esto termino el vídeo que se me está haciendo muy, muy, muy, muy largo. 00:57:04
Pues lo ideal sería es que yo puedo decirle que esta alerta se me ejecute cada vez que arranca el ordenador, ¿vale? 00:57:09
Pues o lo podemos hacer mediante comandos, puedo directamente ejecutar el siguiente comando, voy a abrir un cmd en modo administrador y voy a ejecutar este comando. 00:57:16
Este comando lo que me hace es 00:57:39
Me crea una tarea programada 00:57:44
Ya la veremos en su momento 00:57:46
En lugar de hacerlo en modo gráfico 00:57:47
Lo puedo hacer en modo comando 00:57:50
Le digo que quiero crear una tarea 00:57:52
Le digo que le quiero poner el nombre 00:57:54
EmpiezaAlertaCPU 00:57:56
Le digo cuando quiero que empiece a ejecutarse 00:57:58
Esto quiere decir que cuando arranque el equipo 00:58:01
Y que es lo que quiero que me ejecute 00:58:03
Pues lo que quiero que me ejecute es 00:58:05
un comando que es para trabajar 00:58:07
con los contadores 00:58:09
los conjuntos recopiladores de datos 00:58:11
que se llaman logman, le digo que 00:58:13
quiero que me arranque y quiero que me arranque 00:58:15
el que se llama alerta CPU 00:58:17
¿de acuerdo? y que se me va a ejecutar 00:58:19
en este caso como usuario del sistema 00:58:21
entonces si yo me voy 00:58:23
aquí a el monitor 00:58:25
de rendimiento, yo no sé si 00:58:27
recordáis 00:58:29
que se llamaba alerta 00:58:30
CPU, pues le estoy diciendo que 00:58:35
quiero que me arranque alerta cpu de acuerdo porque repito que este comando que vemos aquí 00:58:37
el logman es para trabajar con todo lo que tenemos aquí de acuerdo con los conjuntos 00:58:45
de recopiladores de datos entonces les digo que me arranque si yo esto lo ejecutó 00:58:50
me dice que se ha creado correctamente vamos a ver en el programador de tareas que me ha hecho 00:58:57
Si me voy aquí 00:59:02
Si me voy aquí a bibliotecas 00:59:04
¿Vale? 00:59:11
Si nos aparece aquí 00:59:12
Pues darle aquí a refrescar 00:59:13
Porque simplemente no se está refrescando bien 00:59:14
¿De acuerdo? 00:59:16
Le damos aquí a actualizar 00:59:19
Y ya os tiene que aparecer por aquí 00:59:20
El que hemos hecho 00:59:23
Entonces vamos a ver que ha hecho esto 00:59:24
Porque lo puedo hacer perfectamente de aquí 00:59:25
Pero bueno, ya que estamos 00:59:27
Botón derecho 00:59:28
Propiedades 00:59:29
y estamos viendo 00:59:30
que hemos llamado 00:59:33
empieza alerta CPU 00:59:35
vale 00:59:37
le hemos dicho que desencadenador 00:59:38
que se me ejecute 00:59:41
al iniciar el sistema operativo 00:59:43
de acuerdo, es decir 00:59:45
yo esto, si lo selecciono 00:59:47
y le doy a editar 00:59:49
pues lo que le tengo puesto, que quiero que se me ejecute 00:59:50
al iniciar el sistema operativo 00:59:53
de acuerdo 00:59:55
luego, aquí me voy a cancelar 00:59:58
y luego, ¿qué acción quiero que me haga? 01:00:00
pues lo que quiero que me haga es que me ejecute un programa 01:00:02
¿qué programa quiero que me ejecute? 01:00:04
el programa logman 01:00:06
el programa logman 01:00:07
y quiero que le pase el argumento 01:00:12
estar alerta CPU 01:00:14
y lo que me va a hacer es iniciar ese programa 01:00:15
¿de acuerdo? 01:00:17
todo lo demás, no hemos tocado aquí nada de la configuración 01:00:19
¿de acuerdo? 01:00:22
le vamos a aceptar 01:00:25
Entonces podríamos haberle hecho perfectamente de aquí 01:00:26
Podemos ver si esto no funciona 01:00:28
Si yo reinicio el equipo 01:00:29
Windows y reiniciar 01:00:31
Cuando yo arranque el ordenador 01:00:34
Supuestamente me tiene que arrancar 01:00:36
La alerta 01:00:38
Que empieza por CPU, vale 01:00:40
Reiniciamos 01:00:41
Iniciamos sesión 01:00:43
Y vamos a abrir el monitor de rendimiento a ver si efectivamente funciona o no funciona. 01:00:56
nos vamos a 01:01:02
conjuntos de recopiladores de datos 01:01:20
definidos por el usuario 01:01:22
y yo no sé si veis 01:01:25
que, ¡voilá! 01:01:26
tenemos aquí 01:01:29
funcionando la alerta 01:01:30
si a mi se me ocurre 01:01:33
vale 01:01:34
yo esto como me está funcionando 01:01:37
pues yo que se, imaginaros que mi procesador 01:01:39
está al 100% 01:01:41
ejecuto este programita 01:01:42
ponemos al procesador 01:01:44
al 100% 01:02:00
y aquí lo tenemos 01:02:12
¿de acuerdo? 01:02:13
Esto ya lo cierro porque ya no me interesa 01:02:14
Y aquí tenemos, es decir, no funciona perfectamente 01:02:16
¿De acuerdo? 01:02:19
Pues con esto yo creo que sabéis bastante de alertas de rendimiento 01:02:22
Pues venga, un saludo, hasta luego 01:02:27
Idioma/s:
es
Autor/es:
Fernando Herrero Núñez
Subido por:
Fernando Jesús H.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
58
Fecha:
13 de febrero de 2024 - 17:50
Visibilidad:
Público
Centro:
IES EL CAÑAVERAL
Duración:
1h′ 02′ 32″
Relación de aspecto:
1.97:1
Resolución:
1920x976 píxeles
Tamaño:
256.31 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid