Commandes système PowerShell¶

Administrateur Linux ?

Cette page suit la même structure que la page des commandes Linux pour faciliter la correspondance section par section. Une table d'équivalences Linux ↔ PowerShell est disponible en bas de cette page.

Afficher le chemin courant¶

Get-Location
# alias : pwd

Retourne le chemin du répertoire courant. Équivalent Linux : pwd.

Changer de répertoire¶

Set-Location C:\Users
# alias : cd

Change le répertoire de travail courant. Équivalent Linux : cd /chemin.

Lister le contenu d'un dossier¶

Get-ChildItem
# alias : ls, dir

Affiche les fichiers et dossiers du répertoire courant. Équivalent Linux : ls.

Get-ChildItem -Force

Affiche aussi les éléments cachés. Équivalent Linux : ls -a.

Get-ChildItem | Format-List

Affichage détaillé (permissions, dates, taille). Équivalent Linux : ls -l.

Get-ChildItem -Recurse

Liste récursivement tous les fichiers et sous-dossiers. Équivalent Linux : ls -R ou find ..

Créer un dossier¶

New-Item -ItemType Directory -Name "MonDossier"
# raccourci : mkdir MonDossier

Crée un nouveau dossier. Équivalent Linux : mkdir MonDossier.

Créer un fichier avec du contenu¶

New-Item -ItemType File -Name "fichier.txt" -Value "Mon contenu"

Crée un fichier et y insère du texte. Équivalent Linux : echo "Mon contenu" > fichier.txt.

Supprimer un fichier¶

Remove-Item monfichier.txt
# alias : del, rm

Supprime un fichier. Équivalent Linux : rm monfichier.txt.

Supprimer un dossier et tout son contenu¶

Remove-Item -Path "MonDossier" -Recurse -Force

Supprime récursivement un dossier et tout ce qu'il contient. Équivalent Linux : rm -rf MonDossier.

Copier un fichier ou un dossier¶

Copy-Item -Path "source.txt" -Destination "copie.txt"
# alias : cp, copy

Copie un fichier ou dossier vers une destination. Équivalent Linux : cp source.txt copie.txt.

Déplacer ou renommer¶

Move-Item -Path "ancien.txt" -Destination "nouveau.txt"
# alias : mv, move

Déplace ou renomme un fichier ou dossier. Équivalent Linux : mv ancien.txt nouveau.txt.

Afficher le contenu d'un fichier¶

Get-Content monfichier.txt
# alias : cat, gc

Affiche le contenu d'un fichier. Équivalent Linux : cat monfichier.txt.

Get-Content monfichier.txt -Head 10

Affiche les 10 premières lignes. Équivalent Linux : head -10 monfichier.txt.

Get-Content monfichier.txt -Tail 10

Affiche les 10 dernières lignes. Équivalent Linux : tail -10 monfichier.txt.

2. Gestion des Processus¶

Lister tous les processus¶

Get-Process
# alias : ps, gps

Affiche tous les processus en cours. Équivalent Linux : ps aux.

Top des processus par utilisation CPU¶

Get-Process | Sort-Object CPU -Descending | Select-Object -First 10 Name, Id, CPU

Affiche les 10 processus consommant le plus de CPU. Équivalent Linux : ps aux | sort -k3 -rn | head.

Top des processus par utilisation RAM¶

Get-Process | Sort-Object WorkingSet -Descending | Select-Object -First 10 Name, Id, @{N='RAM(MB)';E={[math]::Round($_.WorkingSet/1MB,2)}}

Affiche les 10 processus consommant le plus de mémoire.

Affichage temps réel des processus¶

while ($true) {
    Clear-Host
    Get-Process | Sort-Object CPU -Descending | Select-Object -First 20 Name, Id, CPU, @{N='RAM(MB)';E={[math]::Round($_.WorkingSet/1MB,2)}}
    Start-Sleep -Seconds 2
}

Rafraîchit l'affichage toutes les 2 secondes. Équivalent Linux : top ou htop.

Arrêter un processus par PID¶

Stop-Process -Id 1234

Termine un processus par son identifiant. Équivalent Linux : kill 1234.

Arrêter un processus par nom¶

Stop-Process -Name "notepad"

Termine tous les processus du nom donné. Équivalent Linux : killall notepad ou pkill notepad.

Forcer l'arrêt d'un processus¶

Stop-Process -Id 1234 -Force

Termine un processus en force, sans demander de confirmation. Équivalent Linux : kill -9 1234.

3. Réseau¶

Afficher la configuration réseau¶

Get-NetIPAddress
# ou : ipconfig

Affiche les adresses IP des interfaces. Équivalent Linux : ip a.

Tester la connectivité¶

Test-Connection google.com
# ou : ping google.com

Envoie des paquets ICMP pour vérifier la connectivité. Équivalent Linux : ping google.com.

Tester un port TCP¶

Test-NetConnection google.com -Port 443

Vérifie qu'un port TCP est ouvert sur un hôte distant. Équivalent Linux : nc -zv google.com 443.

Voir les connexions réseau actives¶

Get-NetTCPConnection | Where-Object State -eq 'Established'
# ou la version classique : netstat -an

Liste les connexions TCP actives. Équivalent Linux moderne : ss -plunt.

Trouver le processus utilisant un port¶

Get-NetTCPConnection -LocalPort 443 | Select-Object LocalAddress, LocalPort, State, @{N='Process';E={(Get-Process -Id $_.OwningProcess).Name}}

Identifie quel processus écoute sur un port donné. Équivalent Linux : ss -tlnp | grep :443.

Télécharger un fichier depuis une URL¶

Invoke-WebRequest -Uri "https://exemple.com/fichier.zip" -OutFile "C:\Temp\fichier.zip"
# alias : curl, wget (mais redirigent vers Invoke-WebRequest)

Télécharge un fichier. Équivalent Linux : wget ou curl -o.

Tracer la route réseau¶

Test-NetConnection google.com -TraceRoute
# ou : tracert google.com

Trace les sauts réseau jusqu'à la destination. Équivalent Linux : traceroute google.com.

Lister et gérer les interfaces réseau¶

Get-NetAdapter

Liste toutes les interfaces. Équivalent Linux : ip link.

Enable-NetAdapter -Name "Ethernet"
Disable-NetAdapter -Name "Ethernet"

Active ou désactive une interface. Équivalent Linux : ip link set eth0 up/down.

Afficher la table ARP¶

Get-NetNeighbor
# ou : arp -a

Affiche les correspondances IP ↔ MAC. Équivalent Linux : arp -a ou ip neigh.

4. Informations Système¶

Informations sur l'OS¶

Get-CimInstance Win32_OperatingSystem

Affiche les infos système (nom OS, version, build, etc.). Équivalent Linux : uname -a.

Utilisation de l'espace disque¶

Get-PSDrive -PSProvider FileSystem | Select-Object Name, @{N='Used(GB)';E={[math]::Round($_.Used/1GB,2)}}, @{N='Free(GB)';E={[math]::Round($_.Free/1GB,2)}}

Affiche l'utilisation de chaque lecteur. Équivalent Linux : df -h.

Taille d'un dossier¶

Get-ChildItem "C:\MonDossier" -Recurse | Measure-Object -Property Length -Sum

Calcule la taille totale d'un dossier. Équivalent Linux : du -sh /mon/dossier.

Utilisation de la mémoire RAM¶

Get-CimInstance Win32_OperatingSystem | Select-Object @{N='TotalRAM(GB)';E={[math]::Round($_.TotalVisibleMemorySize/1MB,2)}}, @{N='FreeRAM(GB)';E={[math]::Round($_.FreePhysicalMemory/1MB,2)}}

Affiche la RAM totale et libre. Équivalent Linux : free -h.

Uptime du système¶

(Get-Date) - (Get-CimInstance Win32_OperatingSystem).LastBootUpTime

Calcule depuis combien de temps la machine est démarrée. Équivalent Linux : uptime.

Messages système et événements récents¶

Get-EventLog -LogName System -Newest 50

Affiche les 50 derniers événements système. Équivalent Linux : dmesg.

Informations CPU¶

Get-CimInstance Win32_Processor

Détails sur le processeur. Équivalent Linux : lscpu.

Informations disques et volumes¶

Get-Disk
Get-Volume

Liste les disques physiques et volumes logiques. Équivalent Linux : lsblk.

Périphériques USB et PCI¶

Get-PnpDevice -Class USB
Get-PnpDevice

Liste les périphériques USB / tous les périphériques. Équivalents Linux : lsusb et lspci.

Rapport système complet¶

systeminfo

Affiche un rapport complet (RAM, OS, patchs, etc.).

Commandes supplémentaires pour l'état du système¶

Utilisation du fichier d'échange (équivalent du swap)¶

Get-CimInstance Win32_PageFileUsage

Affiche l'utilisation du fichier d'échange Windows. Équivalent Linux : free -h pour la partie swap.

Informations sur les barrettes mémoire¶

Get-CimInstance Win32_PhysicalMemory

Détaille les modules RAM installés (taille, fréquence, slot). Équivalent Linux : dmidecode -t memory.

Lister les services¶

Get-Service

Liste tous les services. Équivalent Linux : systemctl list-unit-files ou service --status-all.

Get-Service | Where-Object Status -eq 'Running'

Filtre uniquement les services en cours d'exécution.

Start-Service -Name "NomDuService"
Stop-Service -Name "NomDuService"
Restart-Service -Name "NomDuService"

Démarrer / arrêter / redémarrer un service. Équivalent Linux : systemctl start/stop/restart.

Set-Service -Name "NomDuService" -StartupType Automatic

Active le service au démarrage. Équivalent Linux : systemctl enable.

5. Gestion des Utilisateurs et Permissions¶

Identifier l'utilisateur courant¶

whoami

Affiche l'utilisateur connecté. Équivalent Linux : whoami.

Créer un utilisateur local¶

New-LocalUser -Name "nouvelutilisateur" -Password (Read-Host -AsSecureString)

Crée un utilisateur local. Équivalent Linux : adduser nouvelutilisateur.

Supprimer un utilisateur local¶

Remove-LocalUser -Name "nouvelutilisateur"

Supprime un utilisateur local. Équivalent Linux : deluser nouvelutilisateur.

Ajouter un utilisateur à un groupe¶

Add-LocalGroupMember -Group "Administrators" -Member "nouvelutilisateur"

Ajoute un utilisateur à un groupe local. Équivalent Linux : usermod -aG groupe utilisateur.

Lister utilisateurs et groupes locaux¶

Get-LocalUser
Get-LocalGroup

Équivalent Linux : cat /etc/passwd et cat /etc/group.

Modifier les permissions d'un fichier¶

icacls "C:\MonFichier.txt" /grant utilisateur:F
# F=FullControl, M=Modify, R=Read

Modifie les permissions NTFS. Équivalent Linux : chmod 755 fichier.

Afficher les permissions¶

Get-Acl "C:\MonFichier.txt" | Format-List

Affiche les ACL détaillées. Équivalent Linux : ls -l ou getfacl.

Changer le propriétaire d'un fichier ou dossier¶

$acl = Get-Acl "C:\MonDossier"
$acl.SetOwner([System.Security.Principal.NTAccount]"DOMAINE\Utilisateur")
Set-Acl "C:\MonDossier" $acl

Change le propriétaire. Équivalent Linux : chown utilisateur:groupe fichier.

Comprendre le modèle de permissions NTFS¶

Contrairement à Linux qui utilise un modèle simple (propriétaire / groupe / autres) avec 9 bits de permissions, Windows utilise des ACL (Access Control Lists) : chaque fichier ou dossier possède une liste d'ACE (Access Control Entries) qui spécifient pour chaque utilisateur ou groupe exactement quels droits sont accordés ou refusés.

Les permissions de base NTFS¶

Permission	Code `icacls`	Équivalent approximatif Linux
Lecture	`R`	`r` (4)
Écriture	`W`	`w` (2)
Lecture et exécution	`RX`	`r-x` (5)
Modification	`M`	`rw-` (6) — lecture + écriture + suppression
Contrôle total	`F`	`rwx` (7) + changement de permissions et de propriétaire

Il n'existe pas de notation octale en NTFS — chaque permission est nominative par utilisateur/groupe.

Les permissions avancées¶

NTFS distingue plus finement que Linux. Par exemple, "modifier" se décompose en :

Permission	Description
`ReadData` / `ListDirectory`	Lire le contenu
`WriteData` / `CreateFiles`	Écrire ou créer des fichiers
`AppendData` / `CreateDirectories`	Ajouter en fin / créer des sous-dossiers
`ReadAttributes`	Lire les attributs basiques
`WriteAttributes`	Modifier les attributs basiques
`ReadExtendedAttributes`	Lire les attributs étendus
`WriteExtendedAttributes`	Modifier les attributs étendus
`ExecuteFile` / `Traverse`	Exécuter / traverser
`DeleteSubdirectoriesAndFiles`	Supprimer le contenu d'un dossier
`Delete`	Supprimer l'élément lui-même
`ReadPermissions`	Lire les permissions
`ChangePermissions`	Modifier les permissions
`TakeOwnership`	S'approprier l'élément

Lire les permissions avec `icacls`¶

icacls "C:\MonDossier"

Affiche les ACL sous forme lisible :
C:\MonDossier BUILTIN\Administrators:(F)
              NT AUTHORITY\SYSTEM:(F)
              BUILTIN\Users:(RX)
              DOMAINE\alice:(M)
(F) Full, (M) Modify, (RX) Read+Execute, (W) Write, (R) Read.

Lire les permissions avec `Get-Acl`¶

(Get-Acl "C:\MonDossier").Access | Format-Table IdentityReference, FileSystemRights, AccessControlType, IsInherited

Sortie détaillée avec les droits hérités ou explicites.

Modifier les permissions avec `icacls`¶

icacls "C:\MonFichier.txt" /grant utilisateur:F          # Contrôle total
icacls "C:\MonFichier.txt" /grant utilisateur:M          # Modification
icacls "C:\MonFichier.txt" /grant utilisateur:"RX"       # Lecture + exécution
icacls "C:\MonFichier.txt" /deny utilisateur:W           # Refus d'écriture
icacls "C:\MonFichier.txt" /remove utilisateur           # Retire toutes les permissions

Héritage des permissions¶

Sous NTFS, les permissions sont héritées depuis le dossier parent par défaut. C'est très différent de Linux où l'héritage n'existe pas (sauf via les ACL POSIX optionnelles).

# Désactiver l'héritage et copier les ACL héritées
icacls "C:\MonDossier" /inheritance:d

# Désactiver l'héritage et supprimer les ACL héritées
icacls "C:\MonDossier" /inheritance:r

# Réactiver l'héritage
icacls "C:\MonDossier" /inheritance:e

Différences clés Linux Windows¶

Aspect	Linux	Windows NTFS
Modèle	Propriétaire / groupe / autres (9 bits)	Liste d'ACE par utilisateur/groupe
Granularité	3 droits (r, w, x)	~14 permissions distinctes
Notation	Octale (`755`) ou symbolique (`rwxr-xr-x`)	Codes `icacls` (F, M, RX, W, R) ou objet ACL
Héritage	Aucun nativement (ACL POSIX en option)	Hérité du dossier parent par défaut
Refus explicite	Non (l'absence de droit = pas d'accès)	Oui (`/deny` prime sur `/grant`)
Outils CLI	`chmod`, `chown`, `getfacl`, `setfacl`	`icacls`, `Get-Acl`, `Set-Acl`

💡 Pour le modèle de permissions Linux, voir Comprendre le modèle de permissions Unix sur la page Linux.

6. Utilitaires Avancés¶

Rechercher un motif dans un fichier¶

Select-String -Pattern "ERROR" -Path "C:\logs\app.log"

Cherche un motif et affiche le numéro de ligne. Équivalent Linux : grep ERROR app.log.

Recherche récursive de motif¶

Get-ChildItem C:\logs -Recurse -Filter *.log | Select-String -Pattern "ERROR"

Cherche dans tous les .log de l'arborescence. Équivalent Linux : grep -r ERROR /chemin.

Rechercher un fichier par nom¶

Get-ChildItem C:\ -Recurse -File -Filter "*.log" -ErrorAction SilentlyContinue

Cherche un fichier dans une arborescence. Équivalent Linux : find / -type f -name "*.log".

Rechercher un dossier par nom¶

Get-ChildItem C:\ -Recurse -Directory -Filter "MonDossier"

Équivalent Linux : find / -type d -name "MonDossier".

Rechercher les fichiers récemment modifiés¶

Get-ChildItem C:\logs -Recurse -File | Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-7) }

Liste les fichiers modifiés dans les 7 derniers jours. Équivalent Linux : find / -type f -mtime -7.

Rechercher un motif dans tous les fichiers `.log` trouvés¶

Get-ChildItem C:\ -Recurse -Filter "*.log" -ErrorAction SilentlyContinue | ForEach-Object { Select-String -Path $_.FullName -Pattern "erreur" }

Équivalent Linux : find / -type f -name "*.log" -exec grep -H 'erreur' {} \;.

Compresser un dossier¶

Compress-Archive -Path "C:\MonDossier" -DestinationPath "C:\archive.zip"

Crée une archive zip. Équivalent Linux : tar -czvf archive.tar.gz MonDossier.

Décompresser une archive¶

Expand-Archive -Path "C:\archive.zip" -DestinationPath "C:\MonDossier"

Extrait une archive zip. Équivalent Linux : tar -xzvf archive.tar.gz.

Afficher l'aide d'une commande¶

Get-Help Get-Process -Full
Get-Help Get-Process -Examples

Affiche le manuel d'une commande, ou seulement les exemples. Équivalent Linux : man commande.

Créer un alias¶

Set-Alias -Name ll -Value Get-ChildItem

Crée un alias pour la session. Équivalent Linux : alias ll='ls -la'. Pour le rendre persistant, l'ajouter au profil PowerShell ($PROFILE).

Exécuter une commande périodiquement¶

while ($true) { Clear-Host; Get-PSDrive -PSProvider FileSystem; Start-Sleep -Seconds 5 }

Rafraîchit une commande toutes les N secondes. Équivalent Linux : watch -n 5 'df -h'.

Traitement des fichiers (équivalent sed)¶

Remplacer une chaîne dans un fichier¶

(Get-Content "fichier.conf") -replace 'ancien_motif', 'nouveau_motif' | Set-Content "fichier.conf"

Équivalent Linux : sed -i 's/ancien_motif/nouveau_motif/g' fichier.conf.

Nettoyer un fichier (supprimer commentaires et lignes vides)¶

Get-Content "fichier.conf" | Where-Object { $_ -notmatch '^\s*#' -and $_ -match '\S' }

Équivalent Linux : sed -e '/^#/d' -e '/^$/d' fichier.conf.

Extraire les 10 premières lignes utiles¶

Get-Content "fichier.txt" | Where-Object { $_ -match '\S' -and $_ -notmatch '^\s*#' } | Select-Object -First 10

Équivalent Linux : sed '/^#/d; /^[[:space:]]*$/d' fichier.txt | head -10.

Traitement de colonnes (équivalent awk)¶

Afficher des colonnes spécifiques d'un CSV¶

Import-Csv "data.csv" | Select-Object Nom, Email

Méthode privilégiée en PowerShell : accès aux colonnes par nom. Équivalent Linux : awk -F',' '{print $1, $3}' data.csv.

Découper manuellement et afficher des colonnes¶

Get-Content "fichier.txt" | ForEach-Object { $c = $_ -split '\s+'; "$($c[0]) $($c[2])" }

Pour les fichiers non-CSV. Équivalent Linux : awk '{print $1, $3}' fichier.txt.

Somme d'une colonne¶

(Get-Content "data.txt" | ForEach-Object { ($_ -split '\s+')[2] -as [int] } | Measure-Object -Sum).Sum

Additionne la 3e colonne. Équivalent Linux : awk '{sum+=$3} END {print sum}' data.txt.

Formatage tabulaire d'un CSV¶

Import-Csv "input.csv" | ForEach-Object { "{0,-20} {1,-10}" -f $_.Nom, $_.Age }

Équivalent Linux : awk -F',' '{printf "%-20s %-10d\n", $2, $4}' input.csv.

Tri et comptage¶

Top des occurrences¶

Get-Content "fichier.log" | Group-Object | Sort-Object Count -Descending

Équivalent Linux : sort fichier.log | uniq -c | sort -nr.

Tri numérique par colonne¶

Get-Content "data.txt" | Sort-Object { [int]($_ -split '\s+')[1] }

Équivalent Linux : sort -n -k2 data.txt.

Combinaisons utiles¶

Top 10 des IPs dans les logs¶

Get-Content "access.log" | ForEach-Object { ($_ -split ' ')[0] } | Group-Object | Sort-Object Count -Descending | Select-Object -First 10

Équivalent Linux : awk '{print $1}' access.log | sort | uniq -c | sort -nr | head -10.

Processus triés par utilisation mémoire¶

Get-Process | Sort-Object WorkingSet -Descending | Select-Object -First 20 Name, Id, @{N='RAM(MB)';E={[math]::Round($_.WorkingSet/1MB,2)}}

Équivalent Linux : ps aux | awk '{print $2, $4, $11}' | sort -k2rn | head -20.

Recherche d'erreurs avec comptage par fichier¶

Get-ChildItem C:\logs -Recurse | Select-String "ERROR" | Group-Object Path | Select-Object Count, Name

Équivalent Linux : grep -r "ERROR" /var/log/ | awk '{print $1}' | sort | uniq -c.

Fichiers récemment modifiés (triés)¶

Get-ChildItem C:\logs -Recurse -File | Sort-Object LastWriteTime -Descending | Select-Object LastWriteTime, FullName -First 20

Équivalent Linux : find /var/log -type f -mtime -7 -printf "%TY-%Tm-%Td %TT %p\n" | sort -r.

Commandes de transfert de fichiers¶

Forward de clé SSH¶

ssh -i $env:USERPROFILE\.ssh\id_ed -A utilisateur@machine

OpenSSH est natif sur Windows 10+. Équivalent Linux : identique.

Copie entre hôtes via SCP¶

scp source utilisateur@machine:/chemin/destination

Équivalent Linux : identique (OpenSSH client présent).

Copie depuis un partage SMB¶

Copy-Item -Path "\\serveur\partage\fichier" -Destination "C:\local\"

Méthode native Windows pour copier depuis un partage réseau.

Synchronisation de dossiers avec robocopy¶

robocopy C:\source C:\destination /MIR /Z /R:3 /W:5

/MIR miroir, /Z reprend après coupure, /R:3 3 retries, /W:5 5s d'attente. C'est l'équivalent Windows de rsync -avz.

Surveillance avancée¶

Processus utilisant le plus de mémoire virtuelle¶

Get-Process | Sort-Object PagedMemorySize64 -Descending | Select-Object -First 20 Name, Id, @{N='Paged(MB)';E={[math]::Round($_.PagedMemorySize64/1MB,2)}}, @{N='Working(MB)';E={[math]::Round($_.WorkingSet/1MB,2)}}

Top processus par utilisation de mémoire paginée (équivalent du "top swap" Linux).

Logs en temps réel (équivalent `tail -f`)¶

Get-Content "C:\logs\app.log" -Wait

Affiche le contenu d'un fichier et continue à afficher les nouvelles lignes. Équivalent direct de tail -f.

Get-Content "C:\logs\app.log" -Tail 50 -Wait

Démarre par les 50 dernières lignes, puis suit en temps réel.

Get-Content "C:\logs\app.log" -Wait | Where-Object { $_ -match "ERROR|WARN" }

Suivi avec filtre. Équivalent Linux : tail -f /var/log/syslog | grep -iE "error|warn".

Get-Content "C:\logs\access.log" -Wait | ForEach-Object { ($_ -split ' ')[8] } | Group-Object

Stats HTTP en streaming. Équivalent Linux : tail -f access.log | awk '{print $9}' | sort | uniq -c.

7. Personnalisation de l'Environnement¶

Définir une variable d'environnement temporaire¶

$env:MA_VAR = "ma_valeur"

Définit une variable pour la session courante. Équivalent Linux : export MA_VAR=ma_valeur.

Définir une variable d'environnement persistante (utilisateur)¶

[Environment]::SetEnvironmentVariable("MA_VAR", "ma_valeur", "User")

Variable persistante au niveau utilisateur. Équivalent Linux : ajout au ~/.bashrc.

Définir une variable persistante (machine)¶

[Environment]::SetEnvironmentVariable("MA_VAR", "ma_valeur", "Machine")

Variable persistante au niveau système (requiert élévation). Équivalent Linux : ajout à /etc/environment.

Lister toutes les variables d'environnement¶

Get-ChildItem Env:

Équivalent Linux : env ou printenv.

Éditer le profil PowerShell¶

notepad $PROFILE

Le profil PowerShell est l'équivalent du ~/.bashrc. Il est exécuté à chaque ouverture de session.

Si le fichier n'existe pas :
New-Item -Type File -Path $PROFILE -Force

Recharger le profil¶

. $PROFILE

Recharge le profil sans redémarrer la session. Équivalent Linux : source ~/.bashrc.

8. Journalisation¶

Lister les journaux disponibles¶

Get-EventLog -List

Liste tous les journaux d'événements. Équivalent Linux : journalctl --list-boots (proche).

Afficher les N derniers événements¶

Get-EventLog -LogName System -Newest 10

Affiche les 10 derniers événements du journal système.

Filtrer par niveau (erreurs uniquement)¶

Get-EventLog -LogName Application -EntryType Error

Équivalent Linux : journalctl -p err.

Filtrer par date (version moderne `Get-WinEvent`)¶

Get-WinEvent -FilterHashtable @{LogName='System'; StartTime=(Get-Date).AddDays(-1)}

Affiche les événements des dernières 24h. Équivalent Linux : journalctl --since "1 day ago".

Filtrer par intervalle de dates¶

Get-WinEvent -FilterHashtable @{LogName='System'; StartTime='2025-01-01'; EndTime='2025-01-31'}

Équivalent Linux : journalctl --since "2025-01-01" --until "2025-01-31".

Filtrer par service¶

Get-WinEvent -FilterHashtable @{ProviderName='MonService'}

Affiche les événements d'un service spécifique. Équivalent Linux : journalctl -u mon_service.

Filtrer par niveau de criticité¶

Get-WinEvent -FilterHashtable @{LogName='System'; Level=2}
# 1=Critical, 2=Error, 3=Warning, 4=Information

Filtre par niveau. Équivalent Linux : journalctl -p [niveau].

Filtrage XPath avancé¶

Get-WinEvent -LogName System -FilterXPath "*[System[(Level=1)]]"

Pour des filtres complexes (corrélations entre champs). Pas d'équivalent direct sous Linux.

Export en JSON¶

Get-WinEvent -LogName System -MaxEvents 100 | ConvertTo-Json

Équivalent Linux : journalctl -o json.

Suivi en temps réel des événements¶

⚠️ Get-WinEvent n'a pas de mode -f natif. Deux solutions :

Si le log est un fichier texte (recommandé) :

Get-Content "C:\logs\app.log" -Wait

Polling sur l'Event Log Windows :

$lastTime = Get-Date
while ($true) {
    Get-WinEvent -FilterHashtable @{LogName='System'; StartTime=$lastTime} -ErrorAction SilentlyContinue
    $lastTime = Get-Date
    Start-Sleep -Seconds 2
}

Équivalent Linux : journalctl -f.

9. Pare-feu¶

Utilisation du pare-feu Windows (équivalent firewalld)¶

Afficher l'état du pare-feu¶

Get-NetFirewallProfile

État des profils Domain, Public, Private. Équivalent Linux : firewall-cmd --state.

Activer ou désactiver le pare-feu¶

Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled True
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled False

Active ou désactive le pare-feu sur tous les profils.

Ajouter une règle pour autoriser un port¶

New-NetFirewallRule -DisplayName "HTTP" -Direction Inbound -Protocol TCP -LocalPort 80 -Action Allow

Équivalent Linux : firewall-cmd --add-port=80/tcp --permanent.

Ajouter une règle pour autoriser un service¶

New-NetFirewallRule -DisplayName "SSH" -Direction Inbound -Service sshd -Action Allow

Équivalent Linux : firewall-cmd --add-service=ssh --permanent.

Lister les règles actives¶

Get-NetFirewallRule | Where-Object Enabled -eq True | Select-Object DisplayName, Direction, Action

Équivalent Linux : firewall-cmd --list-all ou iptables -L.

Supprimer une règle¶

Remove-NetFirewallRule -DisplayName "HTTP"

Équivalent Linux : firewall-cmd --remove-port=80/tcp --permanent.

Désactiver une règle sans la supprimer¶

Disable-NetFirewallRule -DisplayName "HTTP"

Règles bas niveau (équivalent iptables)¶

Bloquer une adresse IP spécifique¶

New-NetFirewallRule -DisplayName "Block 192.168.1.50" -Direction Inbound -RemoteAddress 192.168.1.50 -Action Block

Équivalent Linux : iptables -A INPUT -s 192.168.1.50 -j DROP.

Sauvegarder et restaurer les règles¶

# Export complet (format binaire)
netsh advfirewall export "C:\backup\firewall.wfw"

# Restauration
netsh advfirewall import "C:\backup\firewall.wfw"

Équivalent Linux : iptables-save > rules.v4 et iptables-restore < rules.v4.

10. DNS¶

Résolution DNS d'un nom¶

Resolve-DnsName google.com

Équivalent Linux : dig google.com +short.

Interroger un type d'enregistrement spécifique¶

Resolve-DnsName google.com -Type MX
# Types : A, AAAA, MX, TXT, CNAME, NS, SOA, PTR

Équivalent Linux : dig MX google.com.

Interroger un serveur DNS spécifique¶

Resolve-DnsName google.com -Server 8.8.8.8

Équivalent Linux : dig google.com @8.8.8.8.

Vider le cache DNS local¶

Clear-DnsClientCache
# ou : ipconfig /flushdns

Force la résolution DNS à nouveau. Équivalent Linux : systemd-resolve --flush-caches ou resolvectl flush-caches.

Afficher le cache DNS¶

Get-DnsClientCache

Liste les entrées actuellement en cache.

Côté serveur DNS Windows (module DnsServer)¶

Ajouter un enregistrement A¶

Add-DnsServerResourceRecordA -ComputerName "DNS01" -ZoneName "domain.com" -Name "serveur" -IPv4Address "192.168.1.10"

Crée un enregistrement de type A pour serveur.domain.com pointant vers 192.168.1.10.

Supprimer un enregistrement¶

Remove-DnsServerResourceRecord -ComputerName "DNS01" -ZoneName "domain.com" -RRType "A" -Name "serveur" -Force

Supprime l'enregistrement A sans demander confirmation.

Lister les enregistrements d'une zone¶

Get-DnsServerResourceRecord -ZoneName "domain.com"

11. Permission¶

Le message d'erreur typique en PowerShell quand on manque de privilèges :

Access to the path '[CHEMIN]' is denied.
L'accès au chemin '[CHEMIN]' est refusé.

ou côté commandes système :

The requested operation requires elevation.
Vous ne disposez pas des droits suffisants pour effectuer cette opération.

Contrairement à Linux où sudo permet d'élever une commande isolée, Windows fonctionne avec l'UAC : l'élévation concerne le processus PowerShell entier, pas une commande spécifique.

Lancer PowerShell en tant qu'administrateur¶

Clic droit sur l'icône PowerShell → Exécuter en tant qu'administrateur.

Lancer une session élevée depuis une console existante¶

Start-Process powershell -Verb RunAs

Ouvre une nouvelle console PowerShell avec élévation.

Exécuter une commande précise en élévation¶

Start-Process powershell -Verb RunAs -ArgumentList "-Command Stop-Service Spooler"

Lance une commande dans un processus élevé puis ferme la console.

Vérifier si la session courante est élevée¶

([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

Retourne True si la session a été lancée avec élévation, False sinon.

12. Table d'équivalences Linux PowerShell¶

Synthèse des principales correspondances pour passer rapidement d'un environnement à l'autre.

Action	Linux	PowerShell
Répertoire courant	`pwd`	`Get-Location` / `pwd`
Changer de répertoire	`cd /chemin`	`Set-Location C:\chemin` / `cd`
Lister le contenu	`ls -la`	`Get-ChildItem -Force` / `ls` / `dir`
Lister récursivement	`ls -R` / `find .`	`Get-ChildItem -Recurse`
Créer un dossier	`mkdir dossier`	`New-Item -ItemType Directory -Name dossier`
Supprimer (récursif)	`rm -rf dossier`	`Remove-Item -Recurse -Force dossier`
Copier	`cp src dst`	`Copy-Item src dst`
Déplacer / renommer	`mv src dst`	`Move-Item src dst`
Afficher contenu	`cat fichier`	`Get-Content fichier`
Premières lignes	`head -10 fichier`	`Get-Content fichier -Head 10`
Dernières lignes	`tail -10 fichier`	`Get-Content fichier -Tail 10`
Suivi en temps réel	`tail -f fichier`	`Get-Content fichier -Wait`
Suivi avec filtre	`tail -f f \\| grep ERR`	`Get-Content f -Wait \\| Where-Object { $_ -match 'ERR' }`

Recherche¶

Action	Linux	PowerShell
Rechercher un motif	`grep motif fichier`	`Select-String -Pattern motif -Path fichier`
Recherche récursive	`grep -r motif /chemin`	`Get-ChildItem /chemin -Recurse \\| Select-String motif`
Insensible à la casse	`grep -i motif`	`Select-String -Pattern motif` (insensible par défaut)
Chercher un fichier	`find / -name "*.log"`	`Get-ChildItem C:\ -Recurse -Filter *.log`
Fichiers modifiés (-7j)	`find / -mtime -7`	`Get-ChildItem \\| Where { $_.LastWriteTime -gt (Get-Date).AddDays(-7) }`

Traitement de texte¶

Action	Linux	PowerShell
Remplacer du texte	`sed 's/a/b/g' f`	`(Get-Content f) -replace 'a','b'`
Découper en colonnes	`awk '{print $1}'`	`ForEach { ($_ -split ' ')[0] }`
Trier	`sort fichier`	`Get-Content fichier \\| Sort-Object`
Dédoublonner + compter	`sort \\| uniq -c`	`Group-Object \\| Select Count,Name`
Top occurrences	`sort \\| uniq -c \\| sort -nr`	`Group-Object \\| Sort-Object Count -Descending`
Compter les lignes	`wc -l fichier`	`(Get-Content fichier).Count`

Processus¶

Action	Linux	PowerShell
Lister les processus	`ps aux`	`Get-Process`
Top CPU/RAM en direct	`top` / `htop`	`while($true){Clear-Host; Get-Process \\| Sort CPU -Desc \\| Select -First 20; sleep 2}`
Tuer par nom	`killall firefox`	`Stop-Process -Name firefox`
Tuer par PID	`kill 1234`	`Stop-Process -Id 1234`
Tuer en force	`kill -9 1234`	`Stop-Process -Id 1234 -Force`

Système¶

Action	Linux	PowerShell
Info noyau/OS	`uname -a`	`Get-CimInstance Win32_OperatingSystem`
Utilisation disque	`df -h`	`Get-PSDrive -PSProvider FileSystem`
Utilisation RAM	`free -h`	`Get-CimInstance Win32_OperatingSystem`
Uptime	`uptime`	`(Get-Date) - (Get-CimInstance Win32_OperatingSystem).LastBootUpTime`
Info CPU	`lscpu`	`Get-CimInstance Win32_Processor`
Redémarrer	`reboot`	`Restart-Computer`
Éteindre	`shutdown -h now`	`Stop-Computer`

Services¶

Action	Linux (systemd)	PowerShell
Lister	`systemctl list-units`	`Get-Service`
Démarrer	`systemctl start svc`	`Start-Service svc`
Arrêter	`systemctl stop svc`	`Stop-Service svc`
Redémarrer	`systemctl restart svc`	`Restart-Service svc`
Activer au boot	`systemctl enable svc`	`Set-Service svc -StartupType Automatic`
Statut	`systemctl status svc`	`Get-Service svc`

Réseau¶

Action	Linux	PowerShell
Config IP	`ip a`	`ipconfig` / `Get-NetIPAddress`
Interfaces	`ip link`	`Get-NetAdapter`
Connexions actives	`ss -plunt`	`Get-NetTCPConnection`
Test port	`nc -zv host 443`	`Test-NetConnection host -Port 443`
Traceroute	`traceroute host`	`Test-NetConnection host -TraceRoute` / `tracert`
Résolution DNS	`dig domain.com`	`Resolve-DnsName domain.com`
Table ARP	`arp -a`	`Get-NetNeighbor`

Pare-feu¶

Action	Linux (firewalld)	PowerShell
Lister les règles	`firewall-cmd --list-all`	`Get-NetFirewallRule`
Ouvrir un port	`firewall-cmd --add-port=80/tcp`	`New-NetFirewallRule -LocalPort 80 -Protocol TCP -Action Allow`
État du pare-feu	`firewall-cmd --state`	`Get-NetFirewallProfile`
Bloquer une IP	`iptables -A INPUT -s IP -j DROP`	`New-NetFirewallRule -RemoteAddress IP -Action Block`

Logs et journalisation¶

Action	Linux (journald)	PowerShell
Lister les logs	`journalctl`	`Get-EventLog -List`
Logs d'un service	`journalctl -u svc`	`Get-WinEvent -FilterHashtable @{ProviderName='svc'}`
Logs depuis date	`journalctl --since "1 day ago"`	`Get-WinEvent -FilterHashtable @{StartTime=(Get-Date).AddDays(-1)}`
Erreurs uniquement	`journalctl -p err`	`Get-EventLog -EntryType Error`
Temps réel	`journalctl -f` / `tail -f`	`Get-Content fichier -Wait`

Permissions¶

Action	Linux	PowerShell
Voir les permissions	`ls -l` / `getfacl`	`Get-Acl chemin` / `icacls chemin`
Modifier permissions	`chmod 755 fichier`	`icacls fichier /grant user:M` ou `Set-Acl`
Changer propriétaire	`chown user:grp f`	`$acl.SetOwner(...)` + `Set-Acl`
Élévation privilèges	`sudo commande`	`Start-Process powershell -Verb RunAs`

Variables et environnement¶

Action	Linux	PowerShell
Lister les variables	`env` / `printenv`	`Get-ChildItem Env:`
Variable temporaire	`export VAR=val`	`$env:VAR = "val"`
Variable persistante	Ajout au `.bashrc`	`[Environment]::SetEnvironmentVariable(...)`
Recharger le profil	`source ~/.bashrc`	`. $PROFILE`
Créer un alias	`alias ll='ls -la'`	`Set-Alias ll Get-ChildItem`

Notes pour qui vient de Linux¶

Texte vs objets : Linux travaille avec des chaînes de texte, PowerShell avec des objets typés. Select-Object, Where-Object, Group-Object manipulent directement les propriétés des objets, donc pas besoin de awk pour découper du texte la plupart du temps.
Pipes : | existe dans les deux, mais en PowerShell il transmet des objets, donc pas de souci d'espaces ou de séparateurs.
Casse : PowerShell est insensible à la casse par défaut (commandes, paramètres, comparaisons). Linux est sensible.
Get-Help ≈ man : Get-Help [cmd] -Full pour le manuel complet, -Examples pour les exemples uniquement.
Verbe-Nom : les commandes PowerShell suivent un schéma Verbe-Nom (Get-Process, Stop-Service, New-Item). Get- pour lire, Set- pour modifier, New- pour créer, Remove- pour supprimer, Start-/Stop-/Restart- pour les services et processus.