PowerBGInfo sur un écran Windows Server avec tuiles système et terminal PowerShell

PowerBGInfo : personnaliser le fond d’écran Windows avec PowerShell

par

PowerBGInfo permet de personnaliser le fond d’écran Windows avec PowerShell en y ajoutant des informations système, des tuiles visuelles, des graphiques et des données utiles pour l’exploitation des serveurs.
L’outil reprend l’idée de BGInfo, mais avec une approche plus moderne et entièrement scriptable pour afficher des informations système sur le bureau d’un serveur Windows.

Le principe est simple : on génère une image de fond d’écran, puis on y ajoute des informations utiles. Cela peut être le nom du serveur, l’utilisateur connecté, l’OS, l’adresse IP, l’espace disque ou même des graphiques.

Le module est puissant, mais sa prise en main peut être confuse. On trouve vite des exemples complets avec des charts, des tuiles, des canvas, des topologies et du JSON.

Le but de cet article est donc de reprendre les bases dans le bon ordre.

On va commencer par installer le module, puis comprendre New-BGInfo, avant d’aller progressivement vers les tuiles, les graphiques et les configurations JSON.

Installation

PowerBGInfo s’installe depuis la PowerShell Gallery.

PowerShell
Install-Module PowerBGInfo -Force

Puis on importe le module :

PowerShell
Import-Module PowerBGInfo

Pour vérifier que le module est bien disponible :

PowerShell
Get-Module PowerBGInfo -ListAvailable

On ne va pas s’attarder ici sur le déploiement en entreprise, les dépôts PowerShell internes ou les partages réseau.

Ce sont de vrais sujets, mais ce n’est pas le bon moment. Avant d’industrialiser, il faut comprendre comment le module fonctionne.

Code


son code source est publié sur le repo Git de l’auteur… C’est cadeau !

Le moteur de PowerBGInfo : New-BGInfo

La commande centrale est New-BGInfo.
C’est elle qui génère le fond d’écran.
Sa structure de base ressemble à ça :

PowerShell
New-BGInfo {
    # contenu à afficher
} -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo'

Le paramètre important est le bloc entre accolades.
Ce bloc est un scriptblock PowerShell.
C’est dans ce scriptblock que l’on place les éléments à afficher : valeurs, labels, tuiles, graphiques, topologies, etc.

Autrement dit :

PowerShell
New-BGInfo
└── scriptblock
    └── éléments à afficher

PowerBGInfo ne devine pas ce que vous voulez afficher. Il exécute le scriptblock, récupère les éléments déclarés, génère l’image, puis applique ou exporte le résultat.

Les options importantes de New-BGInfo

Avant d’ajouter du contenu, il faut comprendre quelques options de New-BGInfo.

Exemple :

PowerShell
New-BGInfo `
    -MonitorIndex 0 `
    -FilePath 'C:\Wallpapers\Server.jpg' `
    -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' `
    -WallpaperFit Fill `
    {
        New-BGInfoLabel -Name 'Serveur Windows'
    }

ConfigurationDirectory

-ConfigurationDirectory indique où PowerBGInfo stocke ses fichiers de travail.

PowerShell
-ConfigurationDirectory 'C:\ProgramData\PowerBGInfo'

C’est quasiment obligatoire dans une approche propre.
Évitez les chemins temporaires ou les dossiers de profil utilisateur si vous voulez quelque chose de stable.

FilePath

-FilePath permet de fournir une image de base.

PowerShell
-FilePath 'C:\Wallpapers\Server.jpg'

C’est un point important.

Sans -FilePath, vous ne maîtrisez pas vraiment l’image de départ. Selon le contexte, PowerBGInfo peut repartir du fond courant, utiliser un fond uni ou produire un rendu noir si vous travaillez avec un fond généré.
Pour un rendu propre et reproductible, fournissez une image de base.
C’est souvent la différence entre un test technique et un fond d’écran présentable.

MonitorIndex

-MonitorIndex indique l’écran ciblé.

PowerShell
-MonitorIndex 0

Sur un serveur, 0 suffit dans la majorité des cas.

WallpaperFit

-WallpaperFit définit la manière dont l’image est ajustée à l’écran.

PowerShell
-WallpaperFit Fill

Les valeurs utiles sont généralement :

PowerShell
Center
Fit
Stretch
Tile
Span
Fill

En pratique, Fill ou Fit sont les plus intéressants.

Target

-Target permet de choisir la cible du rendu.

Exemple :

PowerShell
-Target File

C’est très pratique pour tester sans appliquer directement le fond d’écran.

On peut générer une image, vérifier le rendu, puis seulement ensuite appliquer le wallpaper.

Afficher un texte simple

Premier test : afficher un label.

PowerShell
New-BGInfo -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' {
    New-BGInfoLabel -Name 'Serveur Windows'
}

C’est volontairement minimal.

À ce stade, le but n’est pas de faire joli. Le but est de vérifier que le module génère bien une image avec du contenu.

Afficher une variable PowerShell

L’intérêt de PowerBGInfo est de pouvoir afficher des valeurs issues de PowerShell.

Exemple avec le nom de la machine :

PowerShell
$ComputerName = $env:COMPUTERNAME

New-BGInfo -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' {
    New-BGInfoValue -Name 'Serveur' -Value $ComputerName
}

Ici :

PowerShell
-Name

correspond au libellé affiché.

PowerShell
-Value

correspond à la valeur affichée.

On peut évidemment récupérer des informations plus utiles.

PowerShell
$OS = Get-CimInstance Win32_OperatingSystem

New-BGInfo -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' {
    New-BGInfoValue -Name 'OS' -Value $OS.Caption
}

La logique est simple :

  1. PowerShell récupère l’information.
  2. PowerBGInfo l’affiche.

Utiliser les BuiltInValues

PowerBGInfo fournit aussi des valeurs intégrées.
Elles évitent de réécrire les commandes PowerShell pour les informations courantes.
Exemple :

PowerShell
New-BGInfo -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' {
    New-BGInfoValue -BuiltinValue HostName
    New-BGInfoValue -BuiltinValue FullUserName
    New-BGInfoValue -BuiltinValue OSName
}

C’est la méthode la plus rapide pour produire un fond d’écran utile.
On peut aussi renommer le libellé affiché :

PowerShell
New-BGInfo -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' {
    New-BGInfoValue -BuiltinValue OSName -Name 'Système'
}

Les BuiltInValues sont pratiques pour démarrer.

Mais elles ne remplacent pas les valeurs personnalisées. Dès qu’il faut afficher une information métier, une donnée CMDB, un rôle applicatif ou un état spécifique, on repasse sur -Name et -Value.

Premier exemple lisible

On peut maintenant combiner les bases.

PowerShell
New-BGInfo `
    -FilePath 'C:\Wallpapers\Server.jpg' `
    -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' `
    -WallpaperFit Fill `
    {
        New-BGInfoValue -BuiltinValue HostName -Name 'Serveur'
        New-BGInfoValue -BuiltinValue FullUserName -Name 'Utilisateur'
        New-BGInfoValue -BuiltinValue OSName -Name 'OS'
    }

Ce n’est pas encore un design avancé.
Mais c’est propre, court et compréhensible.

Le canvas : la vraie brique de mise en page

Les valeurs simples suffisent pour faire du BGInfo classique.
Mais PowerBGInfo va plus loin avec le canvas.
Un canvas est une zone graphique qui permet d’organiser l’affichage sous forme de blocs.
La structure est la suivante :

PowerShell
New-BGInfo<br>└── New-BGInfoVisualCanvas<br>    └── New-BGInfoVisualCanvasTile

New-BGInfoVisualCanvas crée la surface visuelle.
New-BGInfoVisualCanvasTile crée les tuiles affichées dans cette surface.

C’est cette partie qui rend PowerBGInfo vraiment intéressant.
On ne se contente plus d’empiler des lignes de texte. On construit une vraie zone d’information.

Première tuile simple

Exemple minimal :

PowerShell
$Tiles = @(
    New-BGInfoVisualCanvasTile `
        -Side Left `
        -Label 'HOSTNAME' `
        -Value '{{HostName}}'
)

New-BGInfo `
    -FilePath 'C:\Wallpapers\Server.jpg' `
    -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' `
    -WallpaperFit Fill `
    {
        New-BGInfoVisualCanvas `
            -Title 'PowerBGInfo' `
            -Subtitle 'Server information' `
            -Tile $Tiles
    }

La tuile contient ici :

PowerShell
-Label

Le libellé de la tuile.

PowerShell
-Value

La valeur principale.

-Side

Le côté du canvas où placer la tuile.
On remarque aussi la syntaxe :

PowerShell
{{HostName}}

Ce sont des valeurs résolues par PowerBGInfo.

Ajouter plusieurs tuiles

On peut créer plusieurs tuiles, à gauche ou à droite.

PowerShell
$Tiles = @(
    New-BGInfoVisualCanvasTile -Side Left  -Label 'HOSTNAME' -Value '{{HostName}}'
    New-BGInfoVisualCanvasTile -Side Left  -Label 'OS'       -Value '{{OSName}}'
    New-BGInfoVisualCanvasTile -Side Right -Label 'USER'     -Value '{{UserName}}'
)

New-BGInfo -FilePath 'C:\Wallpapers\Server.jpg' -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' {
    New-BGInfoVisualCanvas `
        -Title 'Server Context' `
        -Subtitle 'PowerBGInfo visual canvas' `
        -Tile $Tiles
}

Le TP reste court, mais on voit déjà le principe :

  • un tableau de tuiles ;
  • un canvas ;
  • un fond d’écran généré.

Options utiles des tuiles

Les tuiles ne se pilotent pas avec des paramètres -Width et -Height.
Leur rendu dépend du canvas et des options prévues pour les tuiles.

Les options les plus utiles sont :

PowerShell
-Side
-IconKind
-SurfaceStyle
-Label
-Value
-Detail
-Progress
-Accent

Exemple :

PowerShell
New-BGInfoVisualCanvasTile `
    -Side Left `
    -IconKind Storage `
    -SurfaceStyle Raised `
    -Label 'SYSTEM DRIVE' `
    -Value '62% free' `
    -Progress 0.62 `
    -Accent '#0EA5E9FF'

Ce genre de tuile est beaucoup plus lisible qu’une ligne de texte.
Elle permet d’afficher :

  • une information principale ;
  • un contexte ;
  • un état visuel ;
  • un accent couleur.

SurfaceStyle

-SurfaceStyle permet de choisir le style visuel de la tuile.

Les styles utiles sont notamment :

PowerShell
Glass
Outline
Raised

Exemple :

PowerShell
New-BGInfoVisualCanvasTile `
    -Side Left `
    -IconKind Computer `
    -SurfaceStyle Outline `
    -Label 'HOSTNAME' `
    -Value '{{HostName}}'

Le choix du style doit rester sobre.

Sur un fond sombre, Outline ou Glass fonctionne bien.
Sur un fond plus chargé, Raised peut améliorer la lisibilité.

IconKind

-IconKind permet d’ajouter une icône à la tuile.

Exemples utiles :

PowerShell
Computer
Network
OperatingSystem
Cpu
Memory
User
Domain
Terminal
Storage
Shield

Exemple :

PowerShell
New-BGInfoVisualCanvasTile `
    -Side Right `
    -IconKind Cpu `
    -SurfaceStyle Outline `
    -Label 'CPU' `
    -Value '{{CpuLogicalCores}} threads'

Les icônes ne doivent pas décorer pour décorer.
Elles doivent aider à lire plus vite.

Progress

-Progress permet d’ajouter une indication de progression.

Exemple :

PowerShell
New-BGInfoVisualCanvasTile `
    -Side Right `
    -IconKind Shield `
    -SurfaceStyle Raised `
    -Label 'PATCH STATUS' `
    -Value '94% compliant' `
    -Progress 0.94

La valeur attendue est comprise entre 0 et 1.

C’est adapté pour :

  • conformité patching ;
  • espace disque ;
  • progression de déploiement ;
  • état global d’un contrôle.

Mini charts dans les tuiles

Les tuiles peuvent aussi afficher un mini chart.
C’est utile pour montrer une tendance courte sans créer un gros graphique.

Exemple :

PowerShell
New-BGInfoVisualCanvasTile `
    -Side Right `
    -IconKind Cpu `
    -SurfaceStyle Glass `
    -Label 'CPU LOAD' `
    -Value '33% active' `
    -Detail 'Recent activity' `
    -MiniChartKind Area `
    -MiniChartValues 18,26,22,37,48,43,51,35,29,41,33 `
    -MiniChartMaximum 100

Un mini chart doit rester un complément.
Il sert à donner un signal visuel rapide, pas à remplacer un dashboard.

Bon usage :

  • CPU récent ;
  • mémoire récente ;
  • espace disque ;
  • tendance de conformité ;
  • activité courte.

Mauvais usage :

  • trop de valeurs ;
  • trop de tuiles avec des mini charts ;
  • mélange entre progress bar et mini chart sans raison claire.

New-BGInfoChart : les graphiques hors canvas

Les mini charts vivent dans les tuiles.
Les BGInfoChart, eux, sont des graphiques indépendants.
Ils se placent directement sur le fond d’écran.

Exemple simple :

PowerShell
New-BGInfo -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' -BackgroundColor Black {
    New-BGInfoValue -BuiltinValue HostName -Color White

    New-BGInfoChart `
        -Id 'cpu' `
        -Title 'CPU' `
        -Metric CpuPercent `
        -ValueSuffix '%' `
        -Kind Sparkline `
        -MaxPoints 60 `
        -Anchor BottomLeft `
        -OffsetX 20 `
        -OffsetY 20
}

Ici, le graphique affiche une tendance CPU.
Le chart n’est pas dans une tuile. Il est positionné sur le wallpaper avec :

PowerShell
-Anchor
-OffsetX
-OffsetY

Types de graphiques disponibles avec PowerBGInfo

PowerBGInfo s’appuie sur ChartForgeX pour les graphiques.
Les types disponibles couvrent plusieurs besoins :

PowerShell
Sparkline
Line
Area
Bar
HorizontalBar
Gauge
Circle
RadialBar
Bullet
Pie
Donut
ProgressBar
Pictorial

Il ne faut pas tous les utiliser.
Le bon choix dépend du message à afficher.

Sparkline, Line, Area

Pour une tendance.

Exemples :

  • CPU sur les dernières exécutions ;
  • mémoire ;
  • latence ;
  • activité récente.

Bar, HorizontalBar

Pour comparer plusieurs valeurs.

Exemples :

  • volumes ;
  • files d’attente ;
  • compteurs applicatifs.

Gauge, Circle, RadialBar

Pour un KPI unique.

Exemples :

  • taux d’utilisation ;
  • score de conformité ;
  • occupation mémoire.

Pie, Donut

Pour une répartition.

Exemples :

  • disque utilisé / libre ;
  • services running / stopped.

Bullet

Pour comparer une valeur à un objectif.

Exemples :

  • conformité patching ;
  • SLA ;
  • progression de déploiement.

ProgressBar

Pour une progression simple.

Exemples :

  • build ;
  • sauvegarde ;
  • déploiement.

Pictorial

Pour un état visuel très synthétique.

Exemples :

  • nombre de services OK / KO ;
  • nœuds disponibles / indisponibles.

Exemple Donut

PowerShell
New-BGInfo -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' -BackgroundColor Black {
    New-BGInfoChart `
        -Id 'disk-c' `
        -Title 'Disk C' `
        -Kind Donut `
        -Values 72,28 `
        -Labels 'Used','Free' `
        -ValueSuffix '%' `
        -Maximum 100 `
        -DonutCenterValue '72%' `
        -DonutCenterLabel 'Used' `
        -Anchor BottomLeft `
        -OffsetX 20 `
        -OffsetY 20 `
        -NoHistory
}

Ce type de graphique est intéressant si l’information doit vraiment être visuelle.
Mais il faut garder la main légère.
Un fond d’écran serveur n’est pas Grafana.

BGInfoTopology

PowerBGInfo permet aussi d’ajouter des topologies.

C’est utile pour représenter une relation entre composants.

Exemple :

PowerShell
New-BGInfo `
    -FilePath 'C:\Wallpapers\Server.jpg' `
    -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo' `
    -Target File `
    {
        New-BGInfoTopology `
            -Title 'Lab topology' `
            -Subtitle 'Gateway, API, SQL' `
            -Width 560 `
            -Height 310 `
            -Anchor BottomRight `
            -OffsetX 34 `
            -OffsetY 34 `
            -TopologyDefinition {
                New-BGInfoTopologyGroup -Id 'lab' -Label 'Lab Site' -Status Healthy -Symbol region

                New-BGInfoTopologyNode -Id 'gateway' -Label 'Gateway' -Kind Network  -Status Healthy -GroupId 'lab' -Symbol GW
                New-BGInfoTopologyNode -Id 'api'     -Label 'API'     -Kind Service  -Status Healthy -GroupId 'lab' -Symbol API
                New-BGInfoTopologyNode -Id 'sql'     -Label 'SQL'     -Kind Database -Status Warning -GroupId 'lab' -Symbol SQL

                New-BGInfoTopologyEdge -SourceNodeId 'gateway' -TargetNodeId 'api' -Label 'HTTPS' -Kind Connectivity -Status Healthy -Direction Forward
                New-BGInfoTopologyEdge -SourceNodeId 'api'     -TargetNodeId 'sql' -Label '32 ms' -Kind Dependency   -Status Warning -Direction Forward
            }
    }

C’est puissant, mais ce n’est pas indispensable pour une première mise en œuvre.
À utiliser si la topologie apporte une vraie information :

  • lab ;
  • jump server ;
  • serveur applicatif avec dépendances ;
  • environnement de formation ;
  • poste d’exploitation partagé.

Sinon, restez sur les valeurs, les tuiles et un ou deux graphiques.

Utiliser une configuration JSON avec PowerBGInfo

PowerBGInfo peut exporter et rejouer une configuration JSON.

Ce point est important : il ne s’agit pas simplement d’un fichier de paramètres que l’on lit soi-même avec ConvertFrom-Json.

PowerBGInfo sait directement appliquer une configuration JSON avec :

PowerShell
Invoke-BGInfo -Path .\bginfo.json

Pourquoi utiliser du JSON ?

Le JSON devient utile quand on veut séparer deux moments :

  1. la conception du fond d’écran ;
  2. son application.

Exemples :

  • tâche planifiée ;
  • outil RMM ;
  • script de build ;
  • déploiement sur plusieurs machines ;
  • configuration portable ;
  • génération sans modifier le script PowerShell.

Le script PowerShell sert à construire ou exporter la configuration.
Le JSON sert ensuite à rejouer cette configuration.

Exporter une configuration JSON

Exemple :

PowerShell
New-BGInfo `
    -MonitorIndex 0 `
    -JsonPath .\bginfo.json `
    -ExportOnly `
    {
        New-BGInfoValue -BuiltinValue HostName
        New-BGInfoValue -BuiltinValue OSName
    } `
    -ConfigurationDirectory 'C:\ProgramData\PowerBGInfo'

-JsonPath indique le fichier JSON à générer.
-ExportOnly indique que l’on exporte la configuration sans appliquer le fond d’écran.

Ensuite, pour rejouer cette configuration :

PowerShell
Invoke-BGInfo -Path .\bginfo.json

Ce que le JSON conserve

Le JSON conserve les éléments compris par le moteur PowerBGInfo :

  • BuiltInValues ;
  • métriques de charts ;
  • options de layout ;
  • couleurs ;
  • polices ;
  • paramètres de wallpaper ;
  • charts ;
  • canvas ;
  • tuiles ;
  • topologies ;
  • options de cible.

Il peut aussi conserver des tokens dynamiques comme :

PowerShell
{{HostName}}
{{OSName}}
{{UserName}}

Ce que le JSON ne conserve pas

Le JSON ne conserve pas n’importe quel code PowerShell.
Si vous écrivez une boucle PowerShell classique, elle est exécutée au moment de l’export.
Le résultat peut être écrit dans le JSON, mais pas le code PowerShell lui-même.

Exemple :

PowerShell
foreach ($Disk in Get-Disk) {
    # logique PowerShell exécutée au moment de l'export
}

Il ne faut donc pas voir le JSON comme un script PowerShell sérialisé.
C’est une configuration PowerBGInfo portable.

Quand rester en PowerShell ?

Restez en PowerShell si :

  • vous êtes en phase de test ;
  • vous avez besoin de logique dynamique ;
  • vous récupérez des données depuis CIM, AD, API ou CMDB ;
  • vous construisez encore le rendu.

Quand passer au JSON ?

Passez au JSON si :

  • le rendu est stable ;
  • vous voulez rejouer la même configuration ;
  • vous voulez l’appeler depuis une tâche planifiée ;
  • vous voulez fournir un artefact simple à un outil de déploiement ;
  • vous voulez limiter la logique exécutée côté serveur.

Conclusion

PowerBGInfo devient beaucoup plus simple quand on le lit dans le bon ordre.
La base, c’est New-BGInfo.
Son cœur, c’est le scriptblock.
Dans ce scriptblock, on ajoute progressivement :

  1. des labels ;
  2. des valeurs PowerShell ;
  3. des BuiltInValues ;
  4. un canvas ;
  5. des tuiles ;
  6. des mini charts ;
  7. des charts autonomes ;
  8. éventuellement une topologie ;
  9. puis une configuration JSON si l’on veut rendre le résultat portable.

Le piège est de vouloir tout utiliser immédiatement.
Pour un fond d’écran serveur, la priorité reste la lisibilité.
Un bon PowerBGInfo ne doit pas impressionner.
Il doit permettre de comprendre rapidement sur quelle machine on se trouve, dans quel contexte, et avec quelles informations utiles.

Avatar de Mickael R.
Mickael R.
Automatisation, industrialisation, PowerShell. Et parfois autre chose que le code.

Laisser un commentaire