Le script ci-dessous est une version un peu avancée avec des fonctions de log et de vérification.

SetInstanceFromFileInMM.txt (5,99 kb)

# SET MULTIPLE CLASS INSTANCE FROM LIST, IN MAINTENANCE MODE.

#Parametres
Param(
$ClassName="Microsoft.Windows.Computer", # Name of Class (Not DisplayName to avoid system language differences) 
$MS= "MyMS.Mydomain.com", # Target Management Server
$cred = $(Get-Credential),
$HostFilePath="C:\HostMM.txt", # List of Host to put in Maintenance Mode
$Duration="10", # Duration in minutes (min: 5 minutes)
$LogPath = "C:\MMlog.txt" # Path of Log file
)



function Write-Log 
{ 
    [CmdletBinding()] 
    Param 
    ( 
        [Parameter(Mandatory=$true, 
                   ValueFromPipelineByPropertyName=$true)] 
        [ValidateNotNullOrEmpty()] 
        [Alias("LogContent")] 
        [string]$Message, 
 
        [Parameter(Mandatory=$false)] 
        [Alias('LogPath')] 
        [string]$Path=$LogPath, 
         
        [Parameter(Mandatory=$false)] 
        [ValidateSet("Error","Warn","Info")] 
        [string]$Level="Info", 
         
        [Parameter(Mandatory=$false)] 
        [switch]$NoClobber 
    ) 
 
    Begin 
    { 
        # Set VerbosePreference to Continue so that verbose messages are displayed. 
        $VerbosePreference = 'Continue' 
    } 
    Process 
    { 
         
        # If the file already exists and NoClobber was specified, do not write to the log. 
        if ((Test-Path $Path) -AND $NoClobber) { 
            Write-Error "Log file $Path already exists, and you specified NoClobber. Either delete the file or specify a different name." 
            Return 
            } 
 
        # If attempting to write to a log file in a folder/path that doesn't exist create the file including the path. 
        elseif (!(Test-Path $Path)) { 
            Write-Verbose "Creating $Path." 
            $NewLogFile = New-Item $Path -Force -ItemType File 
            } 
 
        else { 
            # Nothing to see here yet. 
            } 
 
        # Format Date for our Log File 
        $FormattedDate = Get-Date -Format "yyyy-MM-dd HH:mm:ss" 
 
        # Write message to error, warning, or verbose pipeline and specify $LevelText 
        switch ($Level) { 
            'Error' { 
                Write-Error $Message 
                $LevelText = 'ERROR:' 
                } 
            'Warn' { 
                Write-Warning $Message 
                $LevelText = 'WARNING:' 
                } 
            'Info' { 
                Write-Verbose $Message 
                $LevelText = 'INFO:' 
                } 
            } 
         
        # Write log entry to $Path 
        "$FormattedDate $LevelText $Message" | Out-File -FilePath $Path -Append 
    } 
    End 
    { 
    } 
}


# Initiate Log File
$message = "------ START OF MAINTENANCE MODE LOG ------`n`n"
Write-Log -Message $message -Path $LogPath -Level Info -ErrorAction SilentlyContinue


#Check that Host list file exist
if (!(Test-Path -Path $HostFilePath))
    {
    $message = "Unable to find Host list file`n"
    write-host -ForegroundColor red $message
    Write-Log -Message $message -Path $LogPath -Level Error -ErrorAction SilentlyContinue
    exit 1
    }


# Store content of file
$HostList = Get-Content -Path $HostFilePath


#Import of SCOM module
try
{
Import-Module -Name OperationsManager -ErrorAction stop
}
catch
{
$message = "Error during import of SCOM PS module`n"
write-host -ForegroundColor red $message
Write-Log -Message $message -Path $LogPath -Level Error -ErrorAction SilentlyContinue
exit 1
}


#Connection to management server $MS
try
{
New-SCOMManagementGroupConnection -ComputerName $MS -Credential $cred
}
catch
{
$message = "Error during connection to $MS`n"
write-host -ForegroundColor red $message
Write-Log -Message $message -Path $LogPath -Level Error -ErrorAction SilentlyContinue
exit 1
}
 

# Set Start/End Time upon Duration 
$startTime = [DateTime]::Now
$endTime = $startTime.AddMinutes($Duration)


# Get the class
$Class = Get-SCOMClass | where-object {$_.Name -eq $ClassName} -ErrorAction Stop

If ($Class -eq $null)
    {
    $message = "Unable to find `"$ClassName`" Class`n"
    write-host -ForegroundColor red $message
    Write-Log -Message $message -Path $LogPath -Level Error -ErrorAction SilentlyContinue
    exit 1
    }



# Get the instances where displayname match content of $HostList
$Instances = Get-SCOMClassInstance -Class $Class | Where-Object {`
$_.Displayname -in $HostList 
} -ErrorAction Stop

If ($Instances -eq $null)
    {
    $message = "Unable to find instances of `"$ClassName`" Class`n"
    write-host -ForegroundColor red $message
    Write-Log -Message $message -Path $LogPath -Level Error -ErrorAction SilentlyContinue
    exit 1
    }



# Put in Maintenance Mode
$message = "Putting following instances in Maintenance Mode for $Duration minutes...:`n $($Instances | foreach {"$_;`n"})"
write-host $message
Write-Log -Message $message -Path $LogPath -Level Info -ErrorAction SilentlyContinue

    
$Instances | foreach {`
    try
    {
    $message = "`nSetting Maintenance Mode on `"$_`"..."
    write-host $message
    Write-Log -Message $message -Path $LogPath -Level Info -ErrorAction SilentlyContinue
    Start-SCOMMaintenanceMode -Instance $_ -Reason "PlannedOther" -EndTime $endTime -Comment "MM of $_" -ErrorAction Stop
    }
    catch
    {
    $message = "Error setting Maintenance Mode on `"$_`""
    write-host -ForegroundColor red $message
    Write-Log -Message $message -Path $LogPath -Level Error -ErrorAction SilentlyContinue
    }
}
    

# Check and log Maintenance Mode
$message = "Checking Maintenance Mode..."
Write-Log -Message $message -Path $LogPath -Level Info -ErrorAction SilentlyContinue

$Instances | foreach {`
$message = Get-SCOMMaintenanceMode -Instance $_ | foreach {"COMMENT: $($_.Comments) -- START:$($_.StartTime) -- END:$($_.ScheduledEndTime) -- REASON:$($_.Reason) -- USER:$($_.User)`n" } 
Write-Log -Message $message -Path $LogPath -Level Info -ErrorAction SilentlyContinue

}




    

 

A l’instar de la plupart des outils de supervision, Zabbix propose un système de mise en maintenance de la supervision.

Pour configurer une nouvelle maintenance, Aller dans le menu Configuration / Maintenance:

Cliquer Create Maintenance Period

Renseigner le nom de la période.

Intéressant, le choix est donné de collecter ou non les données.

Attention: les champs de date Active Since et Active Till ne représente pas la période de maintenance elle même mais le temps au sein duquel nous allons créer une ou plusieurs périodes dans l’onglet correspondant (Periods)

Dans l’exemple ci-dessous on positionne une plage de temps d’un an.

Aller dans l’onglet Periods. Cliquer Add

4 modes sont disponibles: One Time Only, Daily, Weekly et Monthly.

Dans l’onglet Hosts and groups, selectionner le/les hosts ou le/les host groups

Une fois la période crée, elle apparait en état Approaching lorsque la date Active Since approche.

Lorsque les hosts concernés sont effectivement en période de maintenance, l’icone apparait a coté, jusqu’a la fin de la période.

Dans cet exemple, dans un an, la règle de maintenance passera en mode Expired.

SCOM 2019 UR1 a introduit de nouveaux management packs universels pour Linux. Ils vont permettre de simplifier la supervision des différentes distributions : plus besoin d’un MP différent pour chaque distribution et chaque version de cette distribution, les MP universels pourront gérer toutes les futures versions des distributions supportées.

Cependant, le déploiement de ces MP universels dans un environnement disposant encore du MP RHEL 6 et de serveurs découverts dans cette version provoque un petit souci : la vue Unix/Linux Computers ne se charge plus et l’erreur suivante apparait :

Par ailleurs, l’erreur suivante est visible dans le journal d’événements :

System.ArgumentException: An item with the same key has already been added.
   at System.ThrowHelper.ThrowArgumentException(ExceptionResource resource)
   at System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add)
   at Microsoft.SystemCenter.CrossPlatform.UI.OM.Integration.MonitoringObjectPathToMonitoringObjectDictionary..ctor(IEnumerable`1 monitoringObjects)
   at Microsoft.SystemCenter.CrossPlatform.UI.OM.Integration.UnixComputerOperatingSystemHelper.JoinCollections(IEnumerable`1 managementServers, IEnumerable`1 resourcePools, IEnumerable`1 unixcomputers, IEnumerable`1 operatingSystems)
   at Microsoft.SystemCenter.CrossPlatform.UI.OM.Integration.UnixComputerOperatingSystemHelper.GetUnixComputerOperatingSystemInstances(String criteria)
   at Microsoft.SystemCenter.CrossPlatform.UI.OM.Integration.Administration.UnixAgentQuery.DoQuery(String criteria)
   at Microsoft.EnterpriseManagement.Mom.Internal.UI.Cache.Query`1.DoQuery(String criteria, Nullable`1 lastModified)
   at Microsoft.EnterpriseManagement.Mom.Internal.UI.Cache.Query`1.FullUpdateQuery(CacheSession session, IndexTable& indexTable, Boolean forceUpdate, DateTime queryTime)
   at Microsoft.EnterpriseManagement.Mom.Internal.UI.Cache.Query`1.InternalSyncQuery(CacheSession session, IndexTable indexTable, UpdateReason reason, UpdateType updateType)
   at Microsoft.EnterpriseManagement.Mom.Internal.UI.Cache.Query`1.InternalQuery(CacheSession session, UpdateReason reason)
   at Microsoft.EnterpriseManagement.Mom.Internal.UI.Cache.Query`1.TryDoQuery(UpdateReason reason, CacheSession session)
   at Microsoft.EnterpriseManagement.Mom.Internal.UI.Console.ConsoleJobExceptionHandler.ExecuteJob(IComponent component, EventHandler`1 job, Object sender, ConsoleJobEventArgs args)

La raison en est simple : le nouveau MP universel a découvert une nouvelle fois vos serveurs RHEL 6, ce qui crée des doublons dans la base de données et un plantage de la console lorsqu’elle tente de les lister.

Vous disposez maintenant de deux solutions :

- Supprimer le MP RHEL 6 qui, par ailleurs, n’est plus supporté dans SCOM 2019. Vos serveurs RHEL6 seront toujours supervisés par le MP universel, mais ce dernier ne contient pas exactement les même moniteurs, il faudra donc vérifier qu’il répond à vos besoins. Par ailleurs, si vous aviez développé des règles et moniteurs qui ciblent spécifiquement la classe RHEL 6, il faudra les réécrire.
Par ailleurs, vous ne pourrez plus découvrir de nouveaux serveurs RHEL 6 si vous supprimez ce management pack.

- Désactiver la découverte des serveurs RHEL 6 via un override, puis exécuter la commande Remove-SCOMDisabledClassInstance.

Une fois débarrassé de ces doublons, tout devrait rentrer dans l’ordre !

J’avais publié il y a quelques années un article montrant comment créer et peupler automatiquement des groupes à partir d’une clé de registre, à l’aide d’un script vbs : Création et peuplement dynamique de groupes à partir d’une clé de registre.

J’ai récemment rencontré un besoin similaire, et j’ai cette fois voulu expérimenter une technique différente et que je considère comme plus élégante, car elle ne se base que sur l’utilisation standard de deux modules natifs, sans faire appel au moindre bout de script.

Je ne reviendrai pas ici sur la nécessité de déclarer une classe unhosted, non singleton et avec un attribut clé pour le groupe : tout cela est détaillé dans l’article précédent.

Entrons donc directement dans le vif du sujet !

Comme je viens de le rappeler, un groupe est l’instance d’une classe. Les objets membres de ce groupe sont eux aussi des instances de différentes classe et ils sont rattachés au groupe à l’aide d’une relation de containment.

Notre objectif est donc de créer des instances de la classe du groupe ainsi que des relations de containment entre ces instances et les objets qui vont venir peupler les groupes.

Et pour ce faire, sans utiliser aucun script, il existe un module parfaitement adapté : System.Discovery.FilteredClassAndRelationshipSnapshotDataMapper.

Ce module va tout simplement créer une instance de la classe que vous lui indiquerez, avec les propriétés que vous lui indiquerez ; ainsi qu’une instance de la relation de votre choix, entre les instances indiquées.

Bien entendu, il n’est pas question ici de remplir les champs de manière statique : ce module sera intégré dans votre workflow de découverte et récupérera donc toutes les informations dont il a besoin depuis les modules précédents.

Dans cet exemple, nous souhaitons peupler les groupes à partir d’une clé de registre : nous devrions donc créer notre datasourcemoduletype avec le très classique module Microsoft.Windows.Discovery.RegistryProvider comme datasource, puisque son rôle est justement d’aller lire dans la base de registre.

Mais il existe une solution encore plus simple : un module natif combinant RegistryProvider et SnapshotDataMapper existe déjà ! Il s’agit du module Microsoft.Windows.FilteredRegistryClassAndRelationshipDiscoveryProvider.

Une fois ces éléments mis bout à bout, on arrive au fragment suivant qu’il suffit de modifier en y indiquant la clé de registre qui vous intéresse :

<ManagementPackFragment SchemaVersion="2.0" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <TypeDefinitions>
    <EntityTypes>
      <ClassTypes>
        <ClassType ID="Test.My.Computers.Group" Accessibility="Public" Abstract="false" Base="MSIL!Microsoft.SystemCenter.InstanceGroup" Hosted="false" Singleton="false" Extension="false" >
          <Property ID="RegistryValue" Type="string" AutoIncrement="false" Key="true" CaseSensitive="false" MaxLength="256" MinLength="0" Required="false" Scale="0" />
        </ClassType>
        
      </ClassTypes>
    </EntityTypes>
  </TypeDefinitions>
  <Monitoring>
    <Discoveries>
      <Discovery ID="Test.My.Computers.Group.Discovery" Enabled="true" Target="Windows!Microsoft.Windows.OperatingSystem" ConfirmDelivery="false" Remotable="true" Priority="Normal">
        <Category>Discovery</Category>
        <DiscoveryTypes>
          <DiscoveryClass TypeID="Test.My.Computers.Group">
            <Property TypeID="Test.My.Computers.Group" PropertyID="RegistryValue" />
          </DiscoveryClass>
        </DiscoveryTypes>
        <DataSource ID="DS" TypeID="Windows!Microsoft.Windows.FilteredRegistryClassAndRelationshipDiscoveryProvider">
          <ComputerName>$Target/Host/Property[Type="Windows!Microsoft.Windows.Computer"]/PrincipalName$</ComputerName>
          <RegistryAttributeDefinitions>
            <RegistryAttributeDefinition>
              <AttributeName>RegistryValueExists</AttributeName>
              <Path>SOFTWARE\Test\RegistryValue</Path>
              <PathType>1</PathType>
              <!-- 0=regKey 1=regValue -->
              <AttributeType>0</AttributeType>
              <!-- 0=CheckIfExists (Boolean) 1=treat data as (String) 2=treat data as (Integer) -->
            </RegistryAttributeDefinition>
            <RegistryAttributeDefinition>
              <AttributeName>RegistryValue</AttributeName>
              <Path>SOFTWARE\Test\RegistryValue</Path>
              <PathType>1</PathType>
              <!-- 0=regKey 1=regValue -->
              <AttributeType>1</AttributeType>
              <!-- 0=CheckIfExists (Boolean) 1=treat data as (String) 2=treat data as (Integer) -->
            </RegistryAttributeDefinition>
          </RegistryAttributeDefinitions>
          <Frequency>14400</Frequency>
          <ClassId>$MPElement[Name="Test.My.Computers.Group"]$</ClassId>
          <ClassInstanceSettings>
            <Settings>
              <Setting>
                <Name>$MPElement[Name='System!System.Entity']/DisplayName$</Name>
                <Value>Test My Group - $Data/Values/RegistryValue$</Value>
              </Setting>
              <Setting>
                <Name>$MPElement[Name='Test.My.Computers.Group']/RegistryValue$</Name>
                <Value>$Data/Values/RegistryValue$</Value>
              </Setting>
            </Settings>
          </ClassInstanceSettings>
          <RelationshipId>$MPElement[Name="MSIL!Microsoft.SystemCenter.InstanceGroupContainsEntities"]$</RelationshipId>
          <SourceTypeId>$MPElement[Name="Test.My.Computers.Group"]$</SourceTypeId>
          <SourceRoleSettings>
            <Settings>
              <Setting>
                <Name>$MPElement[Name='Test.My.Computers.Group']/RegistryValue$</Name>
                <Value>$Data/Values/RegistryValue$</Value>
              </Setting>
            </Settings>
          </SourceRoleSettings>
          <TargetTypeId>$MPElement[Name="Windows!Microsoft.Windows.Computer"]$</TargetTypeId>
          <TargetRoleSettings>
            <Settings>
              <Setting>
                <Name>$MPElement[Name='Windows!Microsoft.Windows.Computer']/PrincipalName$</Name>
                <Value>$Target/Host/Property[Type="Windows!Microsoft.Windows.Computer"]/PrincipalName$</Value>
              </Setting>
            </Settings>
          </TargetRoleSettings>
          <Expression>
            <SimpleExpression>
              <ValueExpression>
                <XPathQuery Type="Boolean">Values/RegistryValueExists</XPathQuery>  
              </ValueExpression>
              <Operator>Equal</Operator> 
              <ValueExpression>
                <Value Type="Boolean">true</Value> 
              </ValueExpression>
            </SimpleExpression>
          </Expression>
        </DataSource>
      </Discovery>
    </Discoveries>
  </Monitoring>
  <LanguagePacks>
    <LanguagePack ID="ENU" IsDefault="true">
      <DisplayStrings>
        <DisplayString ElementID="Test.My.Computers.Group">
          <Name>Test Computers Group</Name>
        </DisplayString>
        <DisplayString ElementID="Test.My.Computers.Group.Discovery">
          <Name>Test Computers Group Discovery</Name>
          <Description>This discovery rule creates and populates groups of Windows Computer Objects that contain a registry key, based on this key's value</Description>
        </DisplayString>
      </DisplayStrings>
    </LanguagePack>
  </LanguagePacks>
</ManagementPackFragment>

Le script ci-dessous affiche tout les hosts avec leur status et les templates associés

GetZabbixAlIHostsAndTemplates(Native_API).ps1 (2,46 kb)

### GET ALL ZABBIX HOSTS WITH THEIR STATUS AND TEMPLATES LINKED


Param(
[Parameter(Mandatory=$false)] $baseurl='https://MyZabbixSrv.My.domain/zabbix',
$credential = (Get-Credential -Credential "MyAccount"),
)

 
$global:JsonParams = @{}
     
# 
Function ConnectZabbix($cred,$baseurl)
{
$JsonParams.body =  @{
        "jsonrpc"= "2.0"
        "method"= "user.login"
        "params"= @{
            "user"= $cred.UserName
            "password"= $cred.GetNetworkCredential().Password
        }
        "id"= 1
        "auth"= $null
    } | ConvertTo-Json
    $JsonParams.uri = "$baseurl/api_jsonrpc.php"
    $JsonParams.headers = @{"Content-Type" = "application/json"}
    $JsonParams.method = "Post"
 
 
[System.Net.ServicePointManager]::SecurityProtocol = 'tls12'
[Net.ServicePointManager]::ServerCertificateValidationCallback = {$true}
 
$global:Connresult = Invoke-WebRequest @JsonParams -UseBasicParsing
 
}
 
# Invoke ConnectZabbix
ConnectZabbix -cred $credential -baseurl $baseurl
 
 
 
## GET HOSTS ##
$JsonParams.body = @{
    "jsonrpc"= "2.0"
    "method"= "host.get"
    "params"= @{
        output = "hostid","name","available","status"
        selectParentTemplates = "templateid","name"
        }

    auth = ($Connresult.Content | ConvertFrom-Json).result
    id = 2
} | ConvertTo-Json

$ZabbixHosts = Invoke-WebRequest @JsonParams -UseBasicParsing
$ZabbixHosts = $ZabbixHosts.Content | ConvertFrom-Json



## CREATE EMPTY TABLEAU THAT WILL STORE HOSTS AND TEMPLATES
$HostsAndTemp = @()

foreach ($Zabbhost in $ZabbixHosts.result)
{

$obj = New-Object psobject

$obj | Add-Member -Name "HOSTNAME" -membertype Noteproperty -Value $Zabbhost.name
$obj | Add-Member -Name "ZBX AGENT STATUS" -membertype Noteproperty -Value `
    $( 
      switch ($Zabbhost.status)
      {
      0 {"ENABLED"}
      1 {"DISABLED"}
      }
     )

$obj | Add-Member -Name "ZBX AGENT AVAILABLE" -membertype Noteproperty -Value `
    $( 
      switch ($Zabbhost.available)
      {
      1 {"AVAILABLE"}
      2 {"UNAVAILABLE"}
      0 {"UNKNOWN"}
      }
     )

$obj | Add-Member -Name "ZABBIX TEMPLATES LINKED" -membertype Noteproperty -Value $Zabbhost.parentTemplates.name


$HostsAndTemp += $obj

}


# TABLEAU FINAL
write-host "`n---- $($ZabbixHosts.result.Count) HOSTS ---`n"
write-host "HOSTNAME - ZBX AGENT STATUS - ZBX AGENT AVAILABLE - ZABBIX TEMPLATES LINKED`n"


$HostsAndTemp | sort hostname | ft -AutoSize

Zabbix propose plusieurs manière de superviser des URL. L’exemple ci-dessous propose d’utiliser un ‘Web Scenario’ pour la supervision d’une URL simple (ici www.google.fr).

on commence par créer un template vide qui contiendra la configuration:

NB: Le nom du Host group associé est arbitraire.

Cliquer Add.

Le template vide est crée.

Cliquer “Create Web Scenario”

Name: Check Google

Agent: On positionne Zabbix. ce champs permet de selectionner plusieurs type de client http/navigateur.

Cliquer Steps.

Dans la zone Steps, cliquer sur Add.

name: Google base page

URL: http://www.google.fr

Required Status codes: 200

Cliquer Add

Le Web scenario est crée.

On applique (Link) le template au host devant effectuer le check de supervision.

Apres quelques minutes les données remonte dans la liste des “Latest data” du host concerné. on voit ici que le code HTTP renvoyé est bien 200 (OK)

On crée a présent un trigger (alerte) en charge declencher une alerte sur le cas ou le code HTTP serait different de 200.

Dans les propriétés du template, cliquer Triggers

cliquer en haut a droite Create Trigger

Name: Google Site KO

Clquer sur Add a coté de la zone Expression pour construire la condition de declenchement.

Cliquer sur Select pour aller rechercher l’item crée precedemment.

Selectionner “Response code for step “Google base page”…”

Laisser selectionné la fonction “last()”.

Result: <> 200

cliquer Insert.

A titre d’indication ajouter le nom de l’url surveillée dans le champ URL.

Cliquer Add.

Le trigger est maintenant actif.

Avez vous déjà rencontré l'expérience de la console Powershell ISE qui fige lorsque vous utilisez Sharepoint Online et le MFA ?

Je sais c'est désagréable, surtout quand un script tourne depuis un moment, voici donc un petit contournement pour corriger ce problème.

1. Créez sur votre bureau un raccourcis de Powershell ISE.
2. Sélectionnez le, faites un clic droit et enfin sélectionnez "Propriétés".
3. Dans le champs "Cible", ajoutez " -Mta" à la fin.

Maintenant lorsque vous exécuterez la console, lancez la via ce raccourcis et les problèmes de console qui fige seront un mauvais souvenir.

Lorsque l’on s’aventure dans la modification manuelle du code JSON d’un dashboard, une mauvaise manipulation est vite arrivée et peut résulter dans le blocage complet du dashboard : il n’est plus possible de le modifier, de le sauvegarder ou de revenir en arrière ; tous les boutons sont inopérants.

Heureusement, il est possible de se sortir de ce mauvais pas sans devoir totalement supprimer le dashboard !

En effet, lorsqu’ils sont en cours de modification, les dashboards sont stockés temporairement sur le serveur qui héberge SquaredUp dans le dossier C:\inetpub\wwwroot\SquaredUpv4\User\Packages\VotreLogin\dashboards sous forme de fichier JSON que vous pouvez ouvrir et modifier avec n’importe quel éditeur de texte.

Il vous suffit donc de corriger votre erreur, enregistrer le fichier, rafraichir le dashboard dans la console SquaredUp et le tour est joué, vous avez récupéré la main !

 Suite à mon précédent article d’introduction à SquaredUp, il est maintenant temps de s’intéresser à quelques-uns des problèmes rencontrés lors de la construction de quelques dashboards ; en particulier ici lors de l’utilisation de tuiles de type « Matrix ».

Les tuiles « Matrix » sont très intéressantes car elles permettent d’afficher plusieurs informations sous différents formats (état de l’objet, état d’un moniteur, sparkline de performance, SLA propriété de l’objet…) sur une même ligne :

Certaines subtilités ne sont cependant pas documentées, et on peut rapidement se casser les dents sur une opération qui semblait pourtant simple au premier abord.

Propriété de l’objet

Il est possible d’afficher une colonne contenant simplement une propriété de l’objet au format texte. Dans la capture ci-dessus, on affiche par exemple la propriété DomainDnsName de la classe Microsoft.Windows.Computer.

La syntaxe est très simple (exemple fourni dans la documentation de SquaredUp) :

{
    "title": "Domain DNS",
    "_type": "celltile/text",
    "config": {
        "display": {
            "contentTemplate": "{{properties.domainDnsName}}"
        }
    }
}

Ce que n’indique pas clairement la documentation, c’est l’obligation de respecter strictement la casse du nom de la propriété… à l’exception de son premier caractère, qui doit toujours être écrit en minuscule.

L’exemple le montre bien, mais sans explication écrite c’est loin d‘être évident !

Valeur calculée

SquaredUp utilise la syntaxe Mustache et supporte donc presque toutes les fonctions de transformation issues de Javascript.

Il est donc en théorie possible de ne garder que deux décimales après la virgule lors de l’affichage d’un compteur de performance avec la fonction ToFixed :

"labelTemplate": "{{ (value).ToFixed(2) }}"

Malheureusement, cela résulte en une colonne vide.

Et la raison est identique au point précédent : il est impératif d’utiliser la casse exacte de la syntaxe Javascript… sauf le premier caractère qui doit obligatoirement être en minuscule.

La syntaxte suivante fonctionne donc :

"labelTemplate": "{{ (value).toFixed(2) }}"

Simple à corriger… mais rageant lorsque l’on bute sur le problème !

Valeur d’un objet hébergée dans une colonne « bar »

L’exemple donné par la documentation semble encore une fois d’une simplicité enfantine :

{
    "title": "Memory Usage Bar",
    "_type": "celltile/bar",
    "config": {
        "source": {
            "objectname": "Memory",
            "countername": "PercentMemoryUsed"
        },
        "display": {
            "valueTemplate": "{{(value ? Math.floor(value) : 0)}}"
        }
    }
}

Le nom du compteur, éventuellement un peu de formatage de la valeur via une fonction Javascript et voilà.

Mais lorsque la Matrix est ciblée sur une classe hébergée par une autre, cela ne fonctionne pas : la colonne est vide.

Un peu plus loin dans la documentation, dans la section concernant les sparklines, on trouve l’information suivante : lorsque  la tuile est scopée sur un objet hébergé tel qu’un disque, une base de données ou un site web, il faut modifier la configuration du groupement :

"transforms": [
    {
        "operator": "group",
        "parameters": {
            "keys": [
                "managedEntityId"
            ]
        }
    },
    {
        "operator": "merge",
        "parameters": {
            "sourceKey": "id",
            "targetKey": "key.managedEntityId"
        }
    }
]

Il semble alors naturel de tenter la même modification pour la sparkline. Malheureusement sans succès…

La solution, qui m’a été apportée par le support de SquaredUp, est la suivante :

"transforms": [
    {
        "operator": "merge",
        "parameters": {
            "sourceKey": "id",
            "targetKey": "managedEntityId"
        }
    }
]

Il s’agit quasiment de la même syntaxe, mais en n’utilisant que le merge.

C’est tout pour aujourd’hui !

Le problème

Si vous demandez aujourd’hui à un utilisateur de SCOM quelles sont les plus grandes faiblesses du produit, grandes sont les chances qu’il vous cite au minimum la difficulté de créer des Management Packs avancés ainsi que la lourdeur et le manque d’ergonomie de l’interface utilisateur.

Cette dernière est en effet universellement connue pour être lente (même en ayant réalisé toutes les optimisations possibles) et pour offrir une navigation peu intuitive et assez datée, y compris dans les versions les plus récentes du produit.

En découlent donc une frustration et un manque d’efficacité pour les opérateurs de supervision et la quasi impossibilité de faire adopter le produit aux utilisateurs indirects qui pourraient pourtant en bénéficier : les autres membres des services informatiques préfèrent demander à l’opérateur de chercher les données dont ils ont besoin, et les responsables des applications métier n’ont pas de réelle solution pour bénéficier de dashboards synthétiques qui leur permettraient d’obtenir une vision rapide de l’état de santé de leur application.

Les solutions

Bien sûr, Microsoft tente depuis déjà de nombreuses versions d’améliorer ces points avec différentes propositions de dashboards censés développer les capacités de présentation du produit (plugin Visio, Widgets dans SCOM 2012, dashboards de la console web HTML 5 depuis la version 1801), mais le résultat de ces efforts est toujours resté très en deca des espérances des utilisateurs.

C’est pourquoi différents éditeurs tiers ont tenté d’apporter une meilleure réponse à ce besoin : historiquement, Savision LiveMaps puis plus récemment SquaredUp. C’est à ce dernier arrivé que nous nous intéressons aujourd’hui, car j’ai eu l’opportunité de le redéployer récemment pour un de mes clients.

A quoi ca ressemble ?

Trêve de bavardage, attaquons le sujet par son aspect le plus important : son apparence.

L’interface du produit est des plus moderne, en HTML5 entièrement responsif aussi efficace sur une TV que sur un smartphone et très épurée et efficace.

Chaque dashboard est constitué d’une série de tuiles, chacune contenant un widget parmi les différents types et formats disponibles (alertes, performance, état ;D sous forme de liste, de donut…) et ainsi présenter les informations pertinentes aux différente populations d’utilisateurs :

Décisionnel, avec l’affichage instantané de la disponibilité des SLA de toutes les applications métier :

Infrastructure, avec les indicateurs les plus importants pour une technologie donnée (ici pour SQL) :

Ou encore métier, avec les indicateurs clés de tous les systèmes qui composent un applicatif :

Comment ca marche ?

Très simplement ! L’installation ne prend que quelques minutes et est quasi entièrement automatisée. Le seul composant nécessaire est IIS, l’installeur se charge de son déploiement s’il n’est pas présent sur le serveur et il est parfaitement possible d’installer SquaredUp dans un IIS existant (par exemple sur un serveur hébergeant le role Console Web de SCOM).

La configuration ne nécessite ensuite qu’un accès à la base Datawarehouse de SCOM, aucune base additionnelle n’est nécessaire. Toutes les données affichées proviennent de cette base.

Comme quoi il est possible d’avoir un affichage rapide et efficace sans aucune modification des données ou de leur structure… Microsoft devrait en prendre de la graine !

La construction des dashboards se fait ensuite entièrement graphiquement, directement dans la console web. Ils sont en réalités construits en JSON, qu’il est possible de modifier manuellement au besoin.

C’est tout ?

Différentes éditions existent, et les plus avancées disposent d’options intéressantes : intégrer des données provenant d’une base SQL externe, d’une requête dans Log Analytics ou du résultat de la requête d’une API REST…

Le produit dispose même d’un module nommé VADA qui permet la construction accélérée d’Applications Distribuées complexes, en détectant automatiquement les connexions TCP entre les différentes couches applicatives (load balancer vers frontal web vers backed vers base de données vers…) à l’aide de netstat exécuté en direct !

Cela ne remplace pas une application distribuée construite à l’aide de découvertes dynamiques par un développeur SCOM chevronné, mais c’est incontestablement plus rapide et pratique que la construction visuelle classique.

Ca doit être cher !

Je vous laisserai seul juge de ce point, mais il faut au moins reconnaitre que SquaredUp joue carte sur table en affichant publiquement ses tarifs, ce qui est excessivement rare dans le monde des extensions pour SCOM (plugins et Management Packs d’éditeurs tiers) :

A noter également la disponibilité d’une version d’essai au long cours « COVID19 » : 1 mois de fonctionnalités complètes (édition EAM) avec utilisateurs illimités, puis 6 mois d’édition spéciale avec 1 seul utilisateur nommé mais un nombre de dashboards OpenAccess (non cliquables) illimités. L’occasion parfait de tester le produit !

Des points négatifs ?

Oui, évidemment, il y en a.

SquaredUp n’a rien d’une solution magique : il ne fait qu’afficher de façon ergonomique et efficace les données collectées par SCOM.

Si votre SCOM est laissé à l’abandon depuis des années, mal ou pas tuné… vous aurez les plus grandes difficultés à obtenir un affichage pertinent. A noter que SquaredUp propose via sa société sœur Cookdown un produit tiers gratuit nommé EasyTune pour aider à résoudre ce point.

La construction des dashboard est parfois trop simple, au point que l’on se prend à regretter l’absence de certaines capacités qui nous semblent pourtant évidentes.

La documentation est claire mais pas toujours suffisamment détaillée.

Le support est par contre toujours très disponible pour vous débloquer et ouvert aux suggestions d’amélioration.

Conclusion

Selon moi, SquaredUp devrait être au minimum étudié dans le cadre de tous les déploiements SCOM. Il permet d’apporter à SCOM un point qui lui manque cruellement : la facilité d’accès, en particulier aux utilisateurs non techniques.

Une supervision ne sert à rien si personne ne se sert des données qui en sont issues, et SquaredUp fournit une réponse pertinente à ce manque flagrant dans le produit de base.