PI Services

Le blog des collaborateurs de PI Services

SCOM – SAC ou LTSC ?

Nombre de clients étudient actuellement la migration de leur environnement SCOM 2012 (R2), qui, rappelons-le, a atteint la fin de sa période de support mainstream en juillet 2017.

Il y a actuellement deux possibilités : passer à la version 2016 sortie il y a déjà presque 2 ans ou opter directement pour la version 1801 sortie il y a moins de 2 mois ; sachant qu’il est possible de migrer depuis la version 2012 R2 directement vers ces deux versions, qu’il s’agisse de migration side by side ou in-place.

Commençons par rappeler que ces deux versions ne se distinguent pas par leur architecture ni leur prérequis, ils sont strictement identiques.

La version 1801 étant plus récente, elle contient bien entendu quelques fonctionnalités supplémentaires (et non des moindres, à l’image de la console web enfin 100% html5 et de ses nouveaux dashboards) ; mais ce n’est finalement pas ce qui la différencie fondamentalement de la version 2016. Pour un aperçu détaillé des nouveautés apportées par ces deux versions, technet reste la source la plus appropriée : What’s new in SCOM 2016 et What’s new in SCOM 1801 .

Non, ce qui différencie réellement ces deux versions, c’est plutôt que la sortie de la version 1801 marque la scission en deux branches distinctes de la suite System Center : la Long-Term Service Channel (LTSC) et la Semi-Annual Channel (SAC) ; reprenant ainsi le modèle inauguré avec Windows et SCCM Current Branch.

Ces deux termes désignent le mode de release du produit, autrement dit sa fréquence de parution, sa durée de support et les fonctionnalités qu’il intègre.

Afin de prendre la décision la plus renseignée possible, voici un tour d’horizon de ce que nous savons de ces deux branches… mais aussi (et surtout) de ce que nous ne savons pas encore !

LTSC

Ce mode de release est dans la continuité de ce qui était connu jusqu’ici :

  • Une nouvelle version majeure tous les 3 ans environ, qui devrait suivre les versions LTSC de Windows
  • Une durée de support de 5+5 ans (mainstream+étendu)
  • Des patchs tous les 3-6 mois visant principalement des corrections de bug et de sécurité (Update Rollups)
  • Peu ou pas de nouvelles fonctionnalités pendant la durée de vie du produit

Il n’existe pas encore réellement de release LTSC de System Center (bien qu’on puisse considérer que la version 2016 en est une), mais Microsoft a profité de l’annonce de Windows 2019 pour confirmer la sortie de System Center 2019, qui sera donc la première véritable LTSC (https://cloudblogs.microsoft.com/windowsserver/2018/03/20/introducing-windows-server-2019-now-available-in-preview/).

Il n’est donc pas possible pour le moment d’anticiper avec certitude les choix que Microsoft fera pour cette version, mais certaines suppositions peuvent être faites avec un minimum de fiabilité. Chaque nouvelle version LTSC devrait:

· Intégrer les nouvelles fonctionnalités parues dans les versions SAC précédentes

· Nécessiter d’en passer par une migration pour réaliser le changement de version, qu’elle soit in-place ou side by side, comme pour le passage de SCOM 2012 à 2016 par exemple.

Le mode d’installation des patchs (Update Rollups) devrait rester similaire à ce qui est connu actuellement avec SCOM 2012 et 2016 et devrait donc nécessiter un certain nombre d’étapes manuelles, sans toutefois entrainer d’indisponibilité de la plateforme.

Enfin, s’il semble acquis que la mise à jour vers la future LTSC 2019 sera supportée depuis la version 2016, rien n’indique qu’il sera possible de passer d’une version SAC (1801 et ultérieures) à la version LTSC 2019 ; ni qu’il sera possible de passer de la version LTSC 2019 à une version SAC ultérieure.

Les versions LTSC sont donc à privilégier lorsque la stabilité de l’infrastructure et la durée du support sont les points les plus importants de votre choix.

SAC

Dans ce mode, Microsoft annonce :

  • Une mise à jour tous les 6 mois environ
  • Une durée de support limitée aux 3 dernières versions, donc d’une durée d’environ 18 mois
  • L’ajout régulier de nouvelles fonctionnalités, probablement à chaque mise à jour

Attention : des mises à jour régulières signifient également autant de chances en plus de voir disparaitre des fonctionnalités ou le support de systèmes dépréciés.

La première version SAC est ainsi nommée « SCOM 1801 » en référence à sa date de sortie (Janvier 2018).

On peut donc supposer que la prochaine mise à jour apparaitra en juin-juillet 2018, mais Microsoft n’a pas encore communiqué dessus et n’a donc pas non plus communiqué sur la forme que prendrait cette mise à jour ni sur son mode d’installation.

Il est cependant là aussi possible de faire quelques suppositions à partir des éléments déjà disponibles :

On peut donc s’attendre à ce que le mécanisme de mise à jour vers la prochaine version SAC soit semblable à ce qui existe actuellement pour l’installation des Update Rollups ; autrement dit un processus par définition encore assez manuel mais n’entrainant pas d’indisponibilité de la plateforme.

On peut aussi imaginer qu’un mécanisme « in-console » similaire à celui de SCCM apparaitra à l’avenir, mais il s’agit d’une pure spéculation : Microsoft n’a aucunement communiqué à ce sujet, ni officiellement ni via les demandes de la communauté (https://systemcenterom.uservoice.com/forums/293064-general-operations-manager-feedback/suggestions/33067480-provide-capability-to-apply-update-rollups-from-co )

Par ailleurs, aucune information n’est disponible concernant la possibilité de passer d’une release SAC à une future release LTSC.

Les versions SAC sont donc à privilégier lorsque l’ajout régulier de nouvelles fonctionnalités et le support rapide des nouvelles technologies constituent les points les plus importants, tout en restant vigilant : un cycle de mise à jour rapide peut également entrainer la fin du support de certaines fonctionnalités et technologies à brève échéance (par exemple l’abandon de la supervision d’une ancienne version de Windows, ou l’obligation de mettre à jour la base de données).

Alors, on choisit quoi ?

Comme souvent il n’y a pas de bonne réponse universelle ; d’autant plus ici en raison des nombreuses incertitudes qui entourent encore le futur des 2 branches.

Au final, le choix peut se résumer à cette question : désirez-vous toujours disposer des dernières innovations du produit (ce qui n’est pas un luxe vu le retard qu’il accumule dans certains domaines) au prix d’une potentielle instabilité et au risque de voir disparaitre le support de certaines fonctionnalités ; ou préférez-vous la stabilité et la sécurité apportées par des release plus espacées et plus matures ?

Etant donné la vitesse de l’évolution des technologies (et mon attrait pour les nouvelles fonctionnalités), mon cœur balance évidemment vers la branche SAC. Mais votre point de vue pourrait être tout à fait opposé, et vous pourriez tout aussi bien décider de passer en version 2016 par sécurité, ou d’attendre la sortie en fin d’année de la version LTSC 2019…

Distribuer un profil WiFi par GPO

Contexte

Rajouter quelques PCs portables dans une salle qui ne peut plus accueillir de prises réseaux filaires.

D'abord configurer la connexion WiFi sur un PC portable, puis l’exporter avec la commande

netsh wlan export profile key=clear c:\

 C:\Users\Administrateur>netsh wlan export profile key

 Le profil d'interface « SSID » est enregistré dans le fichier « .\Wi-Fi-SSID.xml »

La clé apparaît en clair sauf avec la commande "netsh wlan export profile"

On crée la gpo sous configuration ordinateur>Paramètres Windows>paramètres de sécurité>Stratégie de réseau sans fil>nouvelle stratégie

On renseigne le SSID et mot de passe, connexion automatique et préférée, mais je change pour l’occasion le nom à diffuser en «Accès-SF »

Je lie la stratégie à une salle donnée.

Le SSID d’origine apparaît en non disponible alors que la connexion Acces-SF est active et connectée.

Les utilisateurs doivent se connecter au moins une fois en filaire sur le poste pour appliquer la stratégie.

SCOM - Les tâches ont disparu de la console

Ces 3 derniers mois, j’ai reçu de plusieurs sources différentes une question concernant la disparition « soudaine » des tâches dans la console lourde SCOM :

image

Autre point commun, ce problème ne concernait à chaque fois que des consoles installées sur des postes utilisateurs, ou publiées sur Citrix. Les tâches étaient par contre bien présentes sur les consoles installées sur les Management Servers, et dans la console Web.

Dans un premier temps, cela me fit penser à une console cliente n’ayant jamais reçu de mise à jour (update rollup) ; c’est un problème que j’avais déjà rencontré il y a quelques années, mais il s’avéra rapidement que cela n’était pas le cas ici.

Une recherche sur le web en me basant sur ces symptômes m’a ensuite orienté vers une quelques articles de blogs assez anciens, indiquant une incompatibilité connue lors de la mise à jour de Savision LiveMaps v1 à v7/8 : https://www.savision.com/knowledge-base/troubleshooting/missing-console-tasks-operations-console-upgrade-live-maps-v78/

Cela semblait cependant assez peu vraisemblable, ces environnements étant beaucoup plus récents. Il me fut d’ailleurs rapidement confirmé qu’ils n’utilisaient de toute facon pas LiveMaps…

Cette piste mis cependant la puce à l’oreille d’un de ces utilisateurs : le problème semblait avoir débuté lors de l’installation de la dernière version (4.0) du management pack HP Oneview, sortie en décembre 2017.

Sa suppression confirma rapidement qu’il était bien le coupable, mais il n’était pas envisageable de se satisfaire de ce contournement, ce management pack étant très utilisé.

Restait donc à trouver où se situait exactement le problème.

Une analyse des journaux d’événements Windows sur les postes concernés par le problème apporta un indice important, puisque l’événement suivant apparaissant dans le journal Application à chaque lancement de la console SCOM:

Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information. : System.Reflection.ReflectionTypeLoadException: Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
   at System.Reflection.RuntimeModule.GetTypes(RuntimeModule module)
   at System.Reflection.Assembly.GetTypes()
   at Microsoft.EnterpriseManagement.Presentation.DeclaredAssemblyLoader.LoadModuleCatalogFromAssembly(IModuleCatalog bootstrapperCatalog, ModuleCatalog catalog, Assembly assembly)
   at Microsoft.EnterpriseManagement.Presentation.DeclaredAssemblyLoader.CreateModuleCatalog(IEnumerable`1 assemblies)
   at Microsoft.EnterpriseManagement.Presentation.DeclaredAssemblyLoader.LoadInternal(IEnumerable`1 assemblies)
   at Microsoft.EnterpriseManagement.Presentation.DeclaredAssemblyLoader.Load(DeclaredAssembly assembly)
   at Microsoft.EnterpriseManagement.Monitoring.Components.ComponentRegistry.<>c__DisplayClass3e.<GetAssemblies>b__3c(DeclaredAssembly declaredAssembly)
   at System.Reactive.Linq.Observable.<>c__DisplayClass413`2.<>c__DisplayClass415.<Select>b__412(TSource x)

Cet événement indique que lors de son lancement, la console échoue à charger un ou plusieurs composants dll ; ce qui pourrait facilement laisser à penser que l’installation du MP Oneview ajoute des dépendances à la console SCOM, qui sont absentes des postes clients.

Un incident ouvert auprès du support HP confirma cette dépendance, ainsi que le contournement qui s’imposait : installer la console OneView sur tous les postes disposant de la console SCOM.

Problème réglé !

Windows Server–Démarrer automatiquement un DCS suite à un reboot

Contexte

Suite à un reboot, l’exécution d’un data collector set créé depuis Perfmon est interrompue.

La console PerfMon permet uniquement de planifier le lancement d’un DCS en fonction de dates spécifiques et non en fonction d’un évènement :

image

Ce post explique comment automatiquement lancer un Data Collector Set à chaque démarrage du serveur.

Résolution

Depuis le Task Scheduler naviguer vers “Library -> Microsoft -> Windows –> PLA” :

image

Sélectionner le DCS souhaité puis ajouter un trigger du type “At system startup” :

image

Windows Server–SYSPREP une machine plus de trois fois

Contexte

Sur une même machine Windows, il est impossible de réaliser plus de 3 sysprep, au bout de la 4eme tentative, l’utilitaire sysprep affiche l’erreur suivante :

image

Microsoft recommande d’utiliser une image d’un système “sysprepé” afin de contourner cette limite.

Cette limite a été mise en place afin que sysprep ne soit pas utilisé pour réinitialiser la période de grâce de 30 jours que Microsoft fourni pour activer la licence.

Résolution

Pour sysprep une même machine plus de trois fois, les étapes suivantes doivent être réalisées :

1. Depuis l’éditeur de registre,

Depuis la l’entrée “HKEY_LOCAL_MACHINE\System\Setup\Status\SysprepStatus”, modifier la valeur de la clé “CleanupState” à 2 et la valeur de la clé “GeneralizationState” à 7 :

image

Depuis la l’entrée “HKEY_LOCAL_MACHINE\Software\Microsoft\WindowsNT\CurrentVersion\SoftwareProtectionPlatform”, modifier la valeur de la clé “SkipRearm” à 1 :

image

2. Depuis un command prompt lancé en tant qu’administrateur,

Exécuter les commandes suivantes :

msdtc -uninstall
msdtc -install

3. Depuis le répertoire “C:\Windows\System32\Sysprep” supprimer le dossier “Panther” :

image

SQL Server–Détecter et modifier les comptes utilisés pour l’exécution de jobs

Contexte

Il arrive souvent qu’un compte utilisateur soit utilisé pour l’exécution d’un job SQL, il s’agit d’une mauvaise pratique car le compte utilisateur peut être amené à changer de mot de passe ce qui provoqueras une erreur d’exécution des jobs en question.

Ce post explique comment détecter puis modifier les comptes utilisés.

Analyse

Le script suivant permet de détecter les jobs exécuté via un compte user (DOMAIN\USER-%) tout en ne remontant pas les jobs lancés par un compte de service (DOMAIN\SERVICE-%).

Les variables “DOMAIN\USER-%” et “DOMAIN\SERVICE-%” sont à modifier en fonction de la nomenclature utilisée pour nommer les comptes. Le “%” correspond à toute chaîne de zéro caractères ou plus Ce caractère générique peut être utilisé comme préfixe ou comme suffixe.

select s.name,l.name
from  msdb..sysjobs s
  left join master.sys.syslogins l on s.owner_sid = l.sid
where l.name like 'DOMAIN\USER-%' and  l.name not like 'DOMAIN\SERVICE-%'

Résolution

Il faut ensuite récupérer le SID du compte utilisateur à changer depuis l’active directory, ainsi que le SID du compte à utiliser, par exemple, SA.

Pour récupérer le SID d’un utilisateur SQL, executer la commande suivante “select sid,name,denylogin from MASTER..syslogins where name='SQLUser'”

Le script suivant permet de modifier l’owner des jobs d’une instance SQL depuis le SID “0x02” vers le SID “0x01” :

UPDATE msdb..sysjobs
SET owner_sid = CONVERT(varbinary(max), '0x01', 1)
where owner_sid = CONVERT(varbinary(max), '0x02', 1)

[Powershell] Ecrire dans un Excel distant.

Exécuter Excel sur un poste Distant.

Quel est l'interêt ?

En dehors du fait qu'installer Excel sur un serveur n'est pas forcément une bonne pratique, dans mon cas cela me permet d'automatiser à 100% mes scripts Powershell, ces derniers fournissent des rapports détaillés à mes interlocuteurs, sans que je n'ai besoin de faire quelques modifications que ce soit (contrairement à un CSV).
Ainsi les scripts tournent de nuit et permettent à chacun de trouver son rapport le matin en arrivant, et ce même pendant mes vacances.

Comment ça marche

Pour exécuter Excel sur un poste distant via Powershell il faudra cumuler 2 paramètres.

  1. Activer CredSSP pour la délégation des identifiants.
  2. Autoriser le compte d'exécution à se servir de l'application Excel à Distance.

Voyons comment réaliser cela.

1- Activer CredSSP

J'ai déjà traité le sujet ICI.

2- Gestion Excel Distant

Attention la modification que nous allons réaliser n'est pas sans conséquence, comme nous pourrons le voir après, l'application Excel devient vraiment limitée pour tout autre utilisateur que celui qui sera déclaré.

Pour pouvoir autoriser le compte d'exécution à se servir de l'application Excel à distance, nous aurons besoin de la MMC.

Sur la machine qui traitera le fichier Excel :

  • Ouvrir la MMC > Ajouter ou supprimer des composants logiciels enfichables > Services de composants.

  • Développer Services de composants > Ordinateurs > Poste de travail > Configuration DCOM

  • Sur "Microsoft Excel Application" faites clic droit "propriétés", dans la fenêtre sélectionnez l'onglet "Identité"

  • Cochez la case "Cet utilisateur" puis faites "parcourir", sélectionnez "Tout l'annuaire" et enfin recherchez le compte d'exécution du script.

  • Entrez le mot de passe de votre compte d'exécution et faites "Appliquer".

Maintenant que le paramètre est fixé seul le compte définit est "autorisé" à se servir de l'application Microsoft Excel, l'expérience pour tout autre utilisateur est vraiment dégradé (pas d'impression, de sauvegarde, message d'erreur...); par conséquent si vous souhaitez pouvoir continuer à utiliser Excel, je vous invite à repasser sur "L'utilisateur exécutant" et n'activer la fonction que lors de l'exécution du script (pour ma part je ne l'active sur mon poste que la nuit).

Exemple de message d'erreur.

 

Annexe

En annexe un petit article sur la gestion d'Excel en Powershell :

https://blog.piservices.fr/post/2013/03/27/Powershell-Creation-de28099objets-personnalises

 

Exchange 2013 – Erreur HttpEvent 15021

Problématique

Sur un serveur Exchange 2013, la connexion PowerShell ne s’effectue pas et le portail d’administration affiche une page blanche.

2018-03-29_105153

2018-03-29_105411

Dans le journal d’événements système un grand nombre d’erreur HttpEvent 15021 est présent.

2018-03-29_105128

Ces erreurs peuvent intervenir après le changement d’un certificat sur le serveur Exchange.

Résolution

Le problème vient de la liaison du certificat qui est incorrect sur le port 444. Il faut donc la supprimer et la recréer.

Pour cela, afficher l’ensemble des liaisons SSL avec la commande :

netsh http show sslcert

2018-03-29_105203

Récupérer les valeurs du hash et l’application ID de la liaison sur le port 443.

Supprimer la liaison du port 444 avec la commande :

netsh http delete sslcert ipport=0.0.0.0:444

2018-03-29_105239

Et recréer une liaison en utilisant le hash et l’application ID du port 443 avec la commande :

netsh http add sslcert ipport=0.0.0.0:444 certhash=XXXXXXX appid=”{XXXXXXXX}”

2018-03-29_105352

Dans le journal d’événements deux avertissements HttpEvent 15300 et 15301 apparaissent.

2018-03-29_105518

Une fois la modification effectuée, la connexion PowerShell et le portail d'administration sont de nouveau accessibles.

Supervision – SQL – 3 scripts pour la supervision de Always On

 

Dans le cadre d’un portage de règle de supervision, les trois scripts ci-dessous ont été crées pour remonter l’état de:

- Un Availability Group

- Un Availability Replica

- Un Database Replica

 

En pratique ils utilisent a peu près la même requête SQL. Ils contiennent des éléments propre a l’api scom mais peuvent bien sur être adapté pour être utilisé indépendamment.

Ci-dessous les 3 scripts et l’exemple du code du premier, Check_SQL_AO_AvailabilityGroupStatus_Query_Version.ps1.

 

 

#######################################################################################
#         
#
         
#          Script: SQLAlwaysOnAvailGroupStatus.ps1

#          Purpose: Shows AlwaysOn Availability Group Status
#         
#          Parameters:

#           $DBServer: ShortName of DB Server
#          $InstanceFullName: Name of SQL Instance
#          $AvailGroupName: Availability Group Name
#         
#

########################################################################################

param ( 
           
$Arguments,

           
[string]$DBServer,
           
[string]$InstanceFullName,
       
[string]$AvailGroupName
           
                          
           
)


# Create local variables from override value
.([Scriptblock]::Create($Arguments))

$Scriptname = "SQLAlwaysOnAvailabilityReplicaStatus.ps1"


# Name of Instance

$ServerInstance = $InstanceFullName.Split('\')[1]



    #Determine TcpPort Used for Instance
    try
    {
    $TcpPort = Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Microsoft SQL Server\MSSQL11.$ServerInstance\MSSQLServer\SuperSocketNetLib\Tcp\IpAll" | select TcpPort -exp tcpport
    }
    catch
    {
    $Message = "Error during Retrieve of TCP Port Used - Check the execution of the script"
    write-host -f Yellow $Message
    $PropertyBag.AddValue("State","WARNING")
    $PropertyBag.AddValue("Message",$Message)
    $PropertyBag.AddValue("ReplicaName",$AvailabilityReplicaName)
    $PropertyBag
    Exit 1
    }





# Scom Object and Property Bag
$api = New-Object -comObject “MOM.ScriptAPI” 
$PropertyBag = $api.CreatePropertyBag()


# Function  GetAODBRepStatus
Function GetAOAvailGroupStatus
                        {
                        param(
                                    [string]$TargetComputer=$DBServer,
                                    $global:Source = "$DBServer\$ServerInstance",
                                    [string]$sqlCommand =
                                            $("
                                            SELECT
                                           
                                            AO_AG.name as AvailGroupName
                                            ,HADR_AO_AGS.synchronization_health as AvailGroup_SyncHealth
                                            ,HADR_AO_AGS.synchronization_health_desc as AvailGroup_SyncHealth_Desc
                                            --,SYSDB.name as DBName
                                           
                                            --,AO_AVREP.replica_server_name
                                            --,HADR_AVAIL_REP_STATE.synchronization_health as AvailReplica_SyncHealth
                                           
                                            --,HADR_AVAIL_REP_STATE.synchronization_health_desc as AvailReplica_SyncHealth_Desc

                                            --,HADR_DB_REP_STATE.synchronization_state as DBReplica_SyncState
                                            --,HADR_DB_REP_STATE.synchronization_state_desc as DBReplica_SyncState_Desc
                                            --,HADR_DB_REP_STATE.synchronization_health_desc as DBReplica_SyncHealth_Desc

                                           
                                            FROM
                                            [sys].[availability_databases_cluster] AO_DB_CLUS
                                            --INNER JOIN sys.databases SYSDB on CAST(SYSDB.group_database_id AS VARCHAR(50)) =  CAST(AO_DB_CLUS.group_database_id AS VARCHAR(50))
                                            INNER JOIN sys.dm_hadr_database_replica_states HADR_DB_REP_STATE on CAST(HADR_DB_REP_STATE.group_database_id AS VARCHAR(50)) = CAST(AO_DB_CLUS.group_database_id AS VARCHAR(50))
                                            --INNER JOIN sys.dm_hadr_availability_replica_states HADR_AVAIL_REP_STATE on HADR_AVAIL_REP_STATE.group_id = HADR_DB_REP_STATE.group_id
                                            INNER JOIN sys.availability_groups AO_AG on AO_AG.group_id = HADR_DB_REP_STATE.group_id
                                            INNER JOIN sys.dm_hadr_availability_group_states HADR_AO_AGS on HADR_AO_AGS.group_id = AO_AG.group_id
                                            --INNER JOIN [sys].[availability_replicas] AO_AVREP on AO_AVREP.replica_id = HADR_DB_REP_STATE.replica_id
                                            WHERE AO_AG.name = '
$AvailGroupName
'
                                           
                                            GROUP BY
                                            AO_AG.name
                                            ,HADR_AO_AGS.synchronization_health
                                            ,HADR_AO_AGS.synchronization_health_desc
                                            "
                                            )
                               )

                               Try
                               {

                                                                                           
                                               

                                            $global:connectionString = "Data Source=$Source,$TcpPort;" +
                                            "Integrated Security=SSPI; " +
                                            "Initial Catalog=master"

                                           
                                            $connection = new-object system.data.SqlClient.SQLConnection($connectionString)
                                           
                               
                                                               
                                            $connection.Open()
                                                                                 
                                                                              


                                            $command = new-object system.data.sqlclient.sqlcommand($sqlCommand,$connection)

                                }
                                catch
                                {
                                write-host -F Red $("Error during sql connection - check the credentials used").ToUpper()
                                #exit 1
                                }

                                $adapter = New-Object System.Data.sqlclient.sqlDataAdapter $command
                                $set = New-Object System.Data.DataSet
                                $adapter.Fill($Set) | Out-Null

                                $connection.Close()
                                $Set.Tables

                               

                              }




# Execute function and get data
try
{
[array]$AvailGroup = GetAOAvailGroupStatus
}
catch
{
$Message = "WARNING - Error during Connection to master database or execution of sql query"
write-host -F Yellow $Message
$PropertyBag.AddValue("State","WARNING")
$PropertyBag.AddValue("Message",$Message)
$PropertyBag.AddValue("DBServer",$DBServer)
$PropertyBag.AddValue("connectstring",$connectionString)
$PropertyBag.AddValue("AvailGroupName",$AvailGroupName)
$PropertyBag.AddValue("AvailGroupStatus","no_data")
$PropertyBag
exit 1
}



if (!($AvailGroup))
{
$Message = "WARNING - Error - No Availability Group have been found"
write-host -F Yellow $Message
$PropertyBag.AddValue("State","WARNING")
$PropertyBag.AddValue("Message",$Message)
$PropertyBag.AddValue("DBServer",$DBServer)
$PropertyBag.AddValue("AvailGroupName","no_data")
$PropertyBag.AddValue("AvailGroupStatus","no_data")
$PropertyBag
exit 1
}



 

try
{
$AvailGroupState = $AvailGroup  | select AvailGroup_SyncHealth_Desc -ExpandProperty AvailGroup_SyncHealth_Desc
}
catch
{
$Message = "Error during Retrieve of Availability Group State"
Write-Host -ForegroundColor Yellow $Message
$PropertyBag.AddValue("State","WARNING")
$PropertyBag.AddValue("Message",$Message)
$PropertyBag.AddValue("DBServer",$DBServer)
$PropertyBag.AddValue("AvailGroupName",$AvailGroupName)
$PropertyBag.AddValue("AvailGroupStatus","no_data")
$PropertyBag
exit 1
}




"AVAILABILITY GROUP: $AvailGroupName"



If ($AvailGroupState -eq "Healthy")

        {
        $Message = "OK - Status of $AvailGroupName Availability Group is Healthy"
        write-host -f Green $Message
        $PropertyBag.AddValue("State","OK")
        $PropertyBag.AddValue("Message",$Message)
        $PropertyBag.AddValue("DBServer",$DBServer)
        $PropertyBag.AddValue("AvailGroupName",$AvailGroupName)
        $PropertyBag.AddValue("AvailGroupStatus","Healthy")
        $PropertyBag
        Exit 0
        }
       


ElseIf ($AvailGroupState -eq "Error")

   
        {
        $Message = "CRITICAL - Status of $AvailGroupName Availability Group is Error"
        write-host -f Red $Message
        $PropertyBag.AddValue("State","CRITICAL")
        $PropertyBag.AddValue("Message",$Message)
      $PropertyBag.AddValue("DBServer",$DBServer)
        $PropertyBag.AddValue("AvailGroupName",$AvailGroupName)
        $PropertyBag.AddValue("AvailGroupStatus","Error")
        $PropertyBag
        Exit 0
        }
       
Else   {
        $Message = "WARNING - Status of $AvailGroupName Availability Group cannot be determined"
        write-host -f yellow $Message
        $PropertyBag.AddValue("State","WARNING")
        $PropertyBag.AddValue("Message",$Message)
      $PropertyBag.AddValue("DBServer",$DBServer)
        $PropertyBag.AddValue("AvailGroupName",$AvailGroupName)
        $PropertyBag.AddValue("AvailGroupStatus","no_data")
        $PropertyBag
        Exit 1
        }
 
 
########################################################################################

Supervision – Script de corrélation a la seconde

 

Une demande m’a été faite récemment pour la détection de l’occurrence de deux events distinct a la même seconde, ce cas particulier traduisant un problème de sécurité spécifique.

Indépendamment de l’objectif final, il s’agit d’un cas intéressant auquel le script ci-dessous a répondu. Il contient des éléments propre a l’api scom mais peux bien sur être adapté pour être utilisé indépendamment.

 

 

  ##############################################################
### SCRIPT TO DETECT SPECIFIC TWO EVENTS OCCURING AT SAME TIME #####
##############################################################

# PARAMETERS:
### $EventLog: Event Log to look in
### $EventSource: Event Source to search for 

### $FirstEventId: First event to correlate

### $SecondEventId: second event to correlate

### $LastMinutes: Last Time Window to search in
### $DayOfWeekToExclude: Day Of Week To Exclude (Example: "('Saturday','Sunday')" )




param(
$Arguments,
$EventLog,
$EventSource,
$FirstEventId,
$SecondEventId,
$LastMinutes,
$DayOfWeekToExclude
)

$ScriptName = "CorrelateTwoSpecEvent.ps1"

#FUNCTIONS


#Check for the existence of an event source with script name in operation manager eventlog to log some events 
        
Function NewEventSource
 
        
{
 
        
if(!(Test-Path "HKLM:\SYSTEM\CurrentControlSet\services\eventlog\Operations Manager\$ScriptName"))
 
        
{
 
        
New-EventLog -LogName "Operations Manager" -Source $ScriptName
 
        
}

        
} 

#END FUNCTIONS


#Log of script execution 
NewEventSource
 
write-eventlog -logname "Operations Manager" -Source $ScriptName -EventID 1000 -Message "Execution du script $ScriptName" -EntryType Information
 


# Create local variables from override value

.([Scriptblock]::Create($Arguments))

# Determine the moment in the week
if ((Get-date).DayOfWeek -in $DayOfWeekToExclude)
{
# If the day is in $DayOfWeekToExclude -> NO ACTION - END OF SCRIPT
Write-Host "$((Get-date).DayOfWeek) : NO ACTION - END OF SCRIPT"
Exit 0

}

# Create the Scom property bag
$ScomAPI = New-Object -comObject "MOM.ScriptAPI"
$PropertyBag = $ScomAPI.CreatePropertyBag()



$Message =     "SEARCH CRITERIAS: Log: $EventLog - Source: $EventSource - EventId: $FirstEventId or $SecondEventId `n"
$Message


try
{
New-Variable -Name "$($FirstEventId)_Events" -Force -Value $(Get-WinEvent -ErrorAction SilentlyContinue -FilterHashtable @{logname=$EventLog;ProviderName=$EventSource;id=$FirstEventId;StartTime=$(get-date).AddMinutes(-$LastMinutes)})
New-Variable -Name "$($SecondEventId)_Events" -Force -Value $(Get-WinEvent -ErrorAction SilentlyContinue -FilterHashtable @{logname=$EventLog;ProviderName=$EventSource;id=$SecondEventId;StartTime=$(get-date).AddMinutes(-$LastMinutes)})
}
catch
{
$Message = "Error during retrieve of events in the $ScriptName script"
$Message

NewEventSource
Write-EventLog -LogName "operations manager" -Source $ScriptName -EventId 1001 -EntryType Warning -Message "$Message"
Exit 1

}

#If no one of the two events id have occurence no need to continue
if (!$(Get-Variable "$($FirstEventId)_Events").Value -and !$(Get-Variable "$($SecondEventId)_Events").Value)
   
{
   
$Message =  "No one of the two events id have occurences in last $LastMinutes minutes - END OF SCRIPT"
   
$Message

   
Write-EventLog -LogName "operations manager" -Source $ScriptName -EventId 1002 -EntryType Information -Message "$Message"

   
Exit 0

   
}


#If Only one of the two events id have occurences no need to continue
if (!$(Get-Variable "$($FirstEventId)_Events").Value -or !$(Get-Variable "$($SecondEventId)_Events").Value)
   
{
   
$Message = "Only one of the two events id have occurences - END OF SCRIPT"
   
$Message

   
Write-EventLog -LogName "operations manager" -Source $ScriptName -EventId 1003 -EntryType Information -Message $Message

   
Exit 0
   
}



$Message = "$($(Get-Variable "$($FirstEventId)_Events").Value.count) occurence of event $FirstEventId and $($(Get-Variable "$($SecondEventId)_Events").Value.count) occurence of event $SecondEventId in the last $LastMinutes minutes"
$Message +=
"`nSTART OF COMPARAISON...`n"
#$Message



#Compare DateTimes at second level
try
{
$CompareResult = Compare-Object -ReferenceObject $(Get-Variable -Name "$($FirstEventId)_Events").Value.timecreated.second -DifferenceObject $(Get-Variable -Name "$($SecondEventId)_Events").Value.timecreated.second -ExcludeDifferent -IncludeEqual -Verbose
}
catch
{
$Message += "Error during comparaison of Date Creation"
$Message

NewEventSource
Write-EventLog -LogName "operations manager" -Source $ScriptName -EventId 1004 -EntryType Warning -Message $Message
Exit 1
}

#If $CompareResult is null, Events have not occureat the same time
If (!($CompareResult))
   
{
   
$Message += "Events $FirstEventId and $SecondEventId have not occured at the same second - No correlation"
   
$Message

   
NewEventSource   
   
Write-EventLog -LogName "operations manager" -Source $ScriptName -EventId 1004 -EntryType Information -Message $Message
   
   
exit 0

   
}

Else
   
{
   
NewEventSource
   
#
   
$Message += "EVENT $FirstEventId and $SecondEventId have occured at same second $($CompareResult.count) times `n"
   
$Message +=
"`nEVENTS OF LAST $LastMinutes MINUTES:`n"
       
   
$Message += $(Get-Variable "$($FirstEventId)_Events").value | foreach {$_} | Out-String
 
   
$Message += $(Get-Variable "$($SecondEventId)_Events").value | foreach {$_} | Out-String

   
$Message
   
Write-EventLog -LogName "operations manager" -Source $ScriptName -EventId 1005 -EntryType Information -Message $Message
   
$PropertyBag.AddValue("State","CRITICAL")
   
$PropertyBag.AddValue("Message",$Message)
   
   
$PropertyBag
   
}