Comment automatiser les tâches répétitives avec PowerShell

La cybersécurité évolue vite, et les professionnels de l’informatique cherchent en permanence à gagner en productivité et en efficacité. Ce guide est consacré à l’automatisation avec PowerShell, l’un des langages de script les plus puissants et les plus répandus aujourd’hui. Il vous permettra de comprendre les principes fondamentaux, les capacités de l’outil et les bonnes pratiques pour automatiser les tâches répétitives avec PowerShell.

Qu’est-ce que PowerShell ?

PowerShell est un framework d’automatisation des tâches et de gestion de la configuration développé par Microsoft. Il fait à la fois office de langage de script et d’interpréteur de commandes interactif pour l’administration système.

PowerShell est très largement utilisé dans de nombreux domaines informatiques : administration système, configuration réseau ou encore cybersécurité. Parmi ses avantages : l’automatisation, la simplification de l’écriture de scripts et la possibilité de gérer des systèmes Windows comme non Windows.

Bien qu’il s’apparente à des langages de script tels que Python ou Bash, PowerShell est conçu pour Windows et s’intègre directement à ses fonctionnalités et à ses applications.

Les bases de PowerShell

Pour maîtriser PowerShell, il faut assimiler des notions fondamentales comme les cmdlets (prononcez « command-lets »), ces commandes légères propres à PowerShell, et les pipelines, qui permettent de transmettre des données d’une cmdlet à l’autre.

Un script PowerShell est une suite de commandes et d’instructions écrites dans le langage de script PowerShell. Il permet d’automatiser des tâches complexes en exécutant plusieurs commandes à la suite.

Pour exploiter PowerShell efficacement, il faut également se familiariser avec l’environnement d’écriture de scripts intégré (ISE) et maîtriser les bases des structures de script : variables, boucles et instructions conditionnelles. Les sections suivantes en donnent des exemples.

Des scripts PowerShell simples pour automatiser

Les scripts PowerShell constituent un puissant outil d’automatisation. Ils permettent de rationaliser les tâches répétitives, de réduire les erreurs humaines et d’économiser un temps et des ressources précieux.

Tâches PowerShell courantes et scripts associés

PowerShell permet d’automatiser une grande variété de tâches. Voici quelques exemples de tâches d’automatisation relativement simples, accompagnés du code PowerShell correspondant et d’une explication des fonctions exécutées.

Création et gestion des comptes utilisateurs

Exemple de code :

New-ADUser -Name "James Roberts" -SamAccountName "jamesroberts" -UserPrincipalName "jamesroberts@ at domain.com" -AccountPassword (ConvertTo-SecureString "ChangeMe123" -AsPlainText -Force)
# Create a new user New-ADUser -Name "James Roberts" -SamAccountName "jamesroberts" -UserPrincipalName "jamesroberts @at domain.com" -AccountPassword (ConvertTo-SecureString "ChangeMe123" -AsPlainText -Force)
# Create a new user

New-ADUser -Name "James Roberts" -SamAccountName "jamesroberts" -UserPrincipalName "jamesroberts@ at domain.com" -AccountPassword (ConvertTo-SecureString "ChangeMe123" -AsPlainText -Force)

 

Explication : ce script crée un nouvel utilisateur dans Active Directory sous le nom « James Roberts », lui attribue un nom de compte SAM (Security Account Manager), définit son nom d’utilisateur principal et précise le mot de passe du compte.

Opérations sur les fichiers et les dossiers

Exemple de code :

# Copy files from one folder to another

$sourceFolder = "C:\source"
$destinationFolder = "D:\destination"

Copy-Item -Path "$sourceFolder\*" -Destination $destinationFolder -Recurse

Explication : ce script copie tous les fichiers du dossier source vers le dossier de destination, sous-répertoires inclus (copie récursive).

Surveillance et reporting de l’utilisation du processeur

Exemple de code :

# Get CPU usage

$cpuUsage = Get-Counter -Counter "\Processor(_Total)% Processor Time"
$cpuUsage.CounterSamples | ForEach-Object {
    Write-Host "Processor: $($_.InstanceName), Usage: $($_.CookedValue)%"
}

Explication : ce script récupère les informations d’utilisation du processeur pour l’ensemble des processeurs et affiche le pourcentage d’utilisation de chacun.

Notre article Comment réduire l’utilisation du processeur pourrait également vous intéresser.

Découvrez d’autres scripts PowerShell dédiés à la surveillance dans le Centre de scripts NinjaOne.

Tâches liées à la sécurité

Exemple de code :

# Check open ports on a remote host

$hostname = "example.com"
$ports = 80, 443, 22
$ports | ForEach-Object {
    $port = $_
    $result = Test-NetConnection -ComputerName $hostname -Port $port
    if ($result.TcpTestSucceeded) {
        Write-Host "Port $port is open"
    } else {
        Write-Host "Port $port is closed"
    }
}

Explication : ce script teste la disponibilité de ports spécifiques sur un hôte distant et indique si chacun de ces ports est ouvert ou fermé.

Découvrez d’autres scripts liés à la sécurité dans le Centre de scripts NinjaOne.

Configuration réseau

Exemple de code :

# Configure a network adapter with a static IP address 

$interfaceName = "Ethernet" 
$ipAddress = "192.168.1.100" 
$subnetMask = "255.255.255.0" 
$gateway = "192.168.1.1" 
$dnsServers = "8.8.8.8", "8.8.4.4" 

New-NetIPAddress -InterfaceAlias $interfaceName -IPAddress $ipAddress -PrefixLength 24 -DefaultGateway $gateway 
Set-DnsClientServerAddress -InterfaceAlias $interfaceName -ServerAddresses $dnsServers 

Explication : ce script configure une carte réseau avec une adresse IP statique, un masque de sous-réseau, une passerelle par défaut et des adresses de serveurs DNS.

Automatiser des tâches complexes avec PowerShell

À mesure que votre maîtrise de PowerShell progresse, vous pouvez automatiser des tâches et des scénarios plus complexes. Voici quelques exemples PowerShell plus avancés, accompagnés d’explications sur les fonctions exécutées :

Surveillance continue des journaux et alertes

Exemple de code :

# Monitor a log file and send an email alert on a specific event

$logFilePath = "C:\logs\app.log"
$keywordToMonitor = "ERROR"
$recipientEmail = "[email protected]"
$smtpServer = "smtp.domain.com"
$smtpPort = 587

Get-Content -Path $logFilePath -Wait | ForEach-Object {
    if ($_ -match $keywordToMonitor) {
        Send-MailMessage -From "[email protected]" -To $recipientEmail -Subject "Error Alert" -SmtpServer $smtpServer -Port $smtpPort
    }
}

Explication : ce script surveille en continu un fichier journal pour y détecter une condition d’erreur en recherchant un mot-clé précis (« ERROR »), puis envoie une alerte par e-mail dès qu’il repère ce mot-clé.

Analyse des journaux et reporting

Exemple de code :

$results | Export-Csv -Path "log_analysis.csv" -NoTypeInformation
# Analyze log files and generate a report $logFiles = Get-ChildItem -Path "C:\logs" -Filter "*.log" -File $results = @() foreach ($logFile in $logFiles) { $logContent = Get-Content -Path $logFile.FullName $errorCount = ($logContent | Select-String -Pattern "ERROR").Count $results += [PSCustomObject]@{ LogFileName = $logFile.Name ErrorCount = $errorCount } } $results | Export-Csv -Path "log_analysis.csv" -NoTypeInformation
# Analyze log files and generate a report

$logFiles = Get-ChildItem -Path "C:\logs" -Filter "*.log" -File
$results = @()

foreach ($logFile in $logFiles) {
    $logContent = Get-Content -Path $logFile.FullName
    $errorCount = ($logContent | Select-String -Pattern "ERROR").Count
    $results += [PSCustomObject]@{
        LogFileName = $logFile.Name
        ErrorCount = $errorCount
    }
}

$results | Export-Csv -Path "log_analysis.csv" -NoTypeInformation

Explication : ce script parcourt un répertoire à la recherche de fichiers journaux, analyse chacun d’eux pour compter les occurrences du mot-clé « ERROR », puis génère un rapport CSV indiquant le nom des fichiers journaux et le nombre d’erreurs.

Notre article Gestion des journaux Linux : techniques avancées et bonnes pratiques pourrait également vous intéresser.

Intégration avec des API tierces

Exemple de code :

# Interact with a REST API to retrieve data

$apiUrl = "https://api.example.com/data"

$headers = @{
"Authorization" = "Bearer YourAuthToken"
}

try {
$data = Invoke-RestMethod -Uri $apiUrl -Headers $headers -Method Get

Write-Host "Received data from the API:"
$data | Format-Table
}
catch {
Write-Host "Failed to retrieve data from the API: $($_.Exception.Message)"
} 

Explication : ce script interagit avec une API REST en envoyant une requête GET authentifiée, traite la réponse de l’API et affiche les données reçues.

Manipulation de données complexes

Exemple de code :

# Transform and aggregate data from multiple sources

$data1 = Import-Csv -Path "source1.csv"
$data2 = Import-Csv -Path "source2.csv"

# Merge data from different sources
$mergedData = $data1 | ForEach-Object {
    $item1 = $_
    $matchingItem = $data2 | Where-Object { $_.ID -eq $item1.ID }
    if ($matchingItem) {
        $_ | Select-Object *, @{Name="AdditionalProperty";Expression={$matchingItem.Property}}
    } else {
        $_
    }
}

# Export the merged data

$mergedData | Export-Csv -Path "merged_data.csv" -NoTypeInformation

Explication : ce script importe les données de deux fichiers CSV, les fusionne à partir d’un identifiant commun et exporte le résultat dans un nouveau fichier CSV.

Études de cas : des tâches d’automatisation concrètes résolues avec PowerShell

Pour illustrer concrètement la puissance de PowerShell, examinons deux situations réelles dans lesquelles l’automatisation avec PowerShell a permis de résoudre des tâches complexes.

Étude de cas n° 1 : gestion des comptes utilisateurs Active Directory

Problème : une grande administration publique comptant plusieurs milliers de collaborateurs avait besoin d’une méthode efficace pour gérer les comptes utilisateurs dans Active Directory. Cette gestion incluait la création de nouveaux comptes, la désactivation ou la suppression des comptes des collaborateurs ayant quitté l’entreprise, et la mise à jour régulière des attributs des utilisateurs.

Solution : PowerShell a été utilisé pour automatiser ces tâches. Les tâches scriptées comprenaient :

1. La création de nouveaux comptes utilisateurs : un script PowerShell a été créé pour lire les informations des utilisateurs dans un fichier CSV et créer automatiquement de nouveaux comptes dans Active Directory avec les attributs appropriés, tels que le nom d’utilisateur, le mot de passe et l’appartenance aux groupes.
2. La désactivation ou la suppression des comptes utilisateurs inactifs : un autre script a été développé pour identifier puis désactiver ou supprimer les comptes des collaborateurs ayant quitté l’entreprise, en se basant sur la date de dernière connexion. Ce script vérifie régulièrement l’activité des utilisateurs et effectue les actions nécessaires.
3. La mise à jour des attributs utilisateurs : des scripts PowerShell ont été planifiés pour s’exécuter à intervalles définis afin de mettre à jour des attributs comme l’intitulé de poste, le service ou les coordonnées, à partir des données du système RH.

Découvrez comment NinjaOne vous aide à gérer facilement les utilisateurs Active Directory.

Étude de cas n° 2 : gestion des correctifs

Problème : un administrateur système travaillant pour un établissement de santé devait s’assurer que tous les serveurs et postes de travail de l’entreprise recevaient régulièrement les derniers correctifs de sécurité afin de se protéger contre les vulnérabilités.

Solution : l’automatisation avec PowerShell a été mise en place pour rationaliser la gestion des correctifs :

1. Déploiement automatisé des correctifs : des scripts PowerShell ont été développés pour se connecter à distance aux serveurs et aux postes de travail et lancer le processus Windows Update. Ces scripts planifient les mises à jour pendant les fenêtres de maintenance afin de limiter les interruptions.
2. Reporting de l’état des correctifs : PowerShell a également servi à générer des rapports sur l’état des correctifs de chaque machine. Ces rapports permettaient de savoir quelles machines étaient à jour et lesquelles nécessitaient une intervention.
3. Conformité aux normes de sécurité : des scripts PowerShell ont été utilisés pour appliquer et vérifier les mises à jour et configurations de sécurité requises, afin d’aider les appareils à respecter les politiques de sécurité définies. »

Ces exemples montrent comment PowerShell automatise les tâches informatiques courantes tout en améliorant l’efficacité, la précision et la sécurité. Dans la pratique, les déploiements peuvent nécessiter des scripts plus complexes et doivent s’adapter aux exigences de chaque entreprise.

Découvrez comment NinjaOne peut automatiser la gestion des correctifs sur tous les terminaux.

Bonnes pratiques pour l’écriture de scripts PowerShell

Les auteurs de scripts PowerShell expérimentés adoptent une syntaxe cohérente et homogène : noms de variables explicites, commentaires pour plus de clarté et organisation logique des scripts. Appliquez les bonnes pratiques suivantes pour automatiser vos tâches en toute sécurité avec PowerShell :

Utilisez les stratégies d’exécution PowerShell

Définissez des stratégies d’exécution PowerShell pour mieux contrôler l’exécution des scripts. Par exemple, RemoteSigned exige que les scripts téléchargés depuis Internet soient signés par un éditeur approuvé, tandis qu’AllSigned impose la signature de tous les scripts et fichiers de configuration par un éditeur approuvé. Les stratégies d’exécution contribuent à réduire le risque d’exécuter involontairement des scripts non fiables, mais elles ne doivent pas être considérées comme une barrière de sécurité.

Consultez le guide vidéo Comprendre les stratégies d’exécution PowerShell.

Utilisez les signatures numériques

Signer numériquement vos scripts PowerShell avec un certificat de signature de code ajoute un niveau de sécurité supplémentaire. Cela garantit que le script n’a pas été modifié depuis sa signature. Lors de l’exécution, PowerShell peut vérifier la signature numérique pour confirmer l’authenticité du script.

Appliquez le principe de moindre privilège

Lorsque vous exécutez des scripts PowerShell, appliquez le principe de moindre privilège. Assurez-vous que le compte utilisateur ou de service qui exécute le script ne dispose que des autorisations strictement nécessaires à l’accomplissement de la tâche. Évitez autant que possible d’utiliser des comptes à privilèges élevés.

Stockez les identifiants de manière sécurisée

Lorsque vos scripts manipulent des identifiants, utilisez des méthodes sécurisées pour les gérer et les récupérer. La cmdlet Get-Credential de PowerShell permet de demander des identifiants de façon sécurisée et de les renvoyer sous la forme d’un objet PSCredential. Évitez d’inscrire en dur les noms d’utilisateur et les mots de passe, et recourez à un coffre d’identifiants ou de secrets sécurisé adapté lorsqu’un stockage persistant est nécessaire.

Validez les données saisies

Nettoyez et validez les données saisies afin de prévenir les attaques par injection de code, comme les injections SQL ou les injections de script. Évitez d’utiliser directement les saisies de l’utilisateur dans l’exécution d’un script sans validation préalable.

Mettez en place une gestion des erreurs

Une gestion rigoureuse des erreurs permet à vos scripts de réagir correctement aux situations imprévues. Évitez d’afficher dans les messages d’erreur des informations sensibles exploitables par des attaquants.

Utilisez des protocoles sécurisés

Pour vous connecter à des systèmes distants ou à des services web, utilisez des protocoles sécurisés comme HTTPS ou SSH. Évitez de transmettre des informations sensibles sur des connexions non chiffrées.

Mettez régulièrement à jour et appliquez les correctifs

Maintenez PowerShell ainsi que l’ensemble des modules et dépendances à jour avec les derniers correctifs et mises à jour de sécurité. Un logiciel obsolète peut être vulnérable à des exploits connus.

Journalisez et auditez

Mettez en place des mécanismes de journalisation et d’audit pour suivre l’exécution des scripts et détecter les activités suspectes. La cmdlet Start-Transcript de PowerShell peut s’avérer utile à cette fin.

Réalisez des revues de code régulières

Procédez à des revues de code régulières de vos scripts PowerShell afin d’identifier d’éventuelles vulnérabilités de sécurité. Envisagez d’utiliser des outils d’analyse de code pour automatiser ce processus.

Suivez les recommandations du secteur

Restez informé des recommandations de sécurité et des exigences de conformité propres à votre secteur (par exemple PCI DSS, HIPAA, RGPD (règlement général sur la protection des données)) qui s’appliquent à votre entreprise. Veillez à ce que les scripts développés respectent ces normes.

Appliquer ces pratiques de sécurité permet de réduire les risques liés à l’écriture de scripts PowerShell et contribue à un environnement informatique plus sûr et plus conforme. La sécurité est un processus continu : réviser et mettre à jour régulièrement vos scripts est indispensable pour rester protégé face à des menaces en constante évolution.

Une stratégie d’automatisation, un gage d’efficacité

Une stratégie d’automatisation PowerShell bien pensée permet aux équipes informatiques d’optimiser leurs opérations, de gagner en évolutivité, de renforcer la sécurité et de conserver de la souplesse. La polyvalence de PowerShell permet d’automatiser des tâches aussi bien simples que complexes, ce qui en fait un outil essentiel pour la performance et l’efficacité.

Les professionnels de l’informatique peuvent s’appuyer sur les conseils présentés ici pour élaborer leur stratégie d’automatisation en toute confiance.

Pour aller plus loin, l’automatisation informatique de NinjaOne propose des outils qui permettent aux équipes informatiques d’automatiser tâches et flux de travail à grande échelle. Elle centralise également la mise à jour, le déploiement de logiciels et la remédiation dans un tableau de bord unique. Les tâches peuvent s’exécuter selon une planification, en réponse à des conditions définies ou à la demande. Les réponses automatisées peuvent aussi être intégrées aux politiques d’appareils et de groupes, avec la possibilité de les contourner ou de les ajuster si nécessaire.