Automatiser de petites tâches

Avant de commencer

Pourquoi automatiser

Imagine : chaque matin, tu dois copier des fichiers dans un dossier de sauvegarde, daté du jour. À la main, c'est 5 minutes de clics, tous les jours, à se tromper une fois sur deux. Avec un script, tu écris la procédure une seule fois, et elle se rejoue en une seconde, sans erreur, autant de fois que tu veux. C'est le cœur du métier : faire faire à la machine ce qui est répétitif.

Ce que tu sauras faire à la fin

0. C'est quoi un script ?

Un script est un simple fichier texte qui contient une liste de commandes. Quand tu « lances » ce fichier, l'ordinateur exécute les commandes l'une après l'autre, de haut en bas, comme si tu les avais tapées toi-même — mais d'un coup.

1. Ton premier script PowerShell

On reste sous Windows pour commencer (tu connais déjà PowerShell). On va créer un fichier .ps1 et le lancer.

Étape 1 — Créer le fichier

Dans ton dossier labo-terminal (ou un nouveau dossier scripts), crée un fichier bonjour.ps1 avec le Bloc-notes, ou en commande :

"Write-Host 'Bonjour, je suis ton premier script !'" | Out-File bonjour.ps1

Étape 2 — Le lancer

.\bonjour.ps1

Bonjour, je suis ton premier script !

2. Construire le script ligne par ligne

Un script à une ligne, c'est peu. On va le faire grandir. Ouvre bonjour.ps1 dans le Bloc-notes (clic droit → Modifier) et écris plusieurs lignes :

Write-Host "=== Sauvegarde GSB ==="
Write-Host "Démarrage..."
Write-Host "Terminé !"

=== Sauvegarde GSB ===
Démarrage...
Terminé !

3. Les variables : mémoriser une valeur

Un script devient utile quand il retient des choses. Une variable, c'est une boîte avec un nom, dans laquelle tu ranges une valeur pour la réutiliser.

$nom = "GSB"
Write-Host "Sauvegarde de l'entreprise $nom"

Sauvegarde de l'entreprise GSB

Une variable bien pratique : la date du jour

$date = Get-Date -Format "yyyy-MM-dd"
Write-Host "Nous sommes le $date"

Nous sommes le 2026-09-21

Les types de variables essentiels

PowerShell est dit « à typage dynamique » : il devine le type selon ce que tu mets. Mais tu peux aussi forcer le type pour éviter les surprises.

Les variables d'environnement — lire le contexte du système

PowerShell expose les variables système via $env:. Pratique pour personnaliser un script sans rien coder en dur :

Write-Host "Tu es connecté en tant que : $env:USERNAME"
Write-Host "Ton poste s'appelle       : $env:COMPUTERNAME"
Write-Host "Ton dossier perso         : $env:USERPROFILE"

Tu es connecté en tant que : marc.dupont
Ton poste s'appelle       : PC-SALLE3-12
Ton dossier perso         : C:\Users\marc.dupont

4. Texte & nombres : les types et les calculs

Une variable peut contenir deux grandes sortes de valeurs : du texte (« GSB », « Marc ») ou des nombres (18, 3.5). Et elles ne se comportent pas pareil — c'est une notion clé de toute programmation.

Les nombres : on peut calculer

$a = 10
$b = 3
Write-Host "Somme : $($a + $b)"
Write-Host "Produit : $($a * $b)"

Somme : 13
Produit : 30

Le texte : on assemble (mais on ne calcule pas)

$prenom = "Marc"
$nom = "Dupont"
Write-Host ($prenom + " " + $nom)

Marc Dupont

Guillemets doubles vs guillemets simples — une distinction clé

En PowerShell (et en bash), les guillemets ne font pas la même chose :

$nom = "Marc"
Write-Host "Bonjour $nom"   # → Bonjour Marc   (interpolation)
Write-Host 'Bonjour $nom'   # → Bonjour $nom   (littéral)

Couper, assembler, extraire — les outils texte du pro

5. Poser une question

Un script encore plus malin demande une info à celui qui le lance.

$reponse = Read-Host "Quel dossier veux-tu sauvegarder ?"
Write-Host "Tu as choisi : $reponse"

Quel dossier veux-tu sauvegarder ?: Documents
Tu as choisi : Documents

6. Les conditions : réagir selon les cas

Un script intelligent fait des choix : « SI telle situation, ALORS fais ceci, SINON fais cela ». C'est le if / else.

$dossier = Read-Host "Nom du dossier à sauvegarder"
if (Test-Path $dossier) {
    Write-Host "OK, le dossier existe, je sauvegarde."
} else {
    Write-Host "Erreur : ce dossier n'existe pas !"
}

Comparer deux valeurs : les opérateurs

Le plus souvent, le test du if compare deux valeurs : un nombre est-il plus grand qu'un autre ? deux textes sont-ils égaux ? Surprise : en PowerShell on n'écrit pas > ni ==, mais des mots-clés qui commencent par un tiret.

$age = Read-Host "Quel age as-tu ?"
if ([int]$age -ge 18) {
    Write-Host "Tu es majeur."
} else {
    Write-Host "Tu es mineur."
}

Quel age as-tu ?: 20
Tu es majeur.

Plusieurs cas : elseif

$note = [int](Read-Host "Ta note sur 20 ?")
if ($note -ge 16) {
    Write-Host "Très bien"
} elseif ($note -ge 10) {
    Write-Host "Admis"
} else {
    Write-Host "À retravailler"
}

Ta note sur 20 ?: 12
Admis

Combiner plusieurs conditions : -and, -or, -not

Parfois un seul test ne suffit pas : « SI l'âge est ≥ 18 ET le pays est France… ». Les opérateurs logiques combinent plusieurs conditions.

$age = [int](Read-Host "Ton âge ?")
$pass = Read-Host "Ton code (1234) ?"

if ($age -ge 18 -and $pass -eq "1234") {
    Write-Host "Accès autorisé."
} elseif ($age -lt 18) {
    Write-Host "Accès refusé : tu es mineur."
} else {
    Write-Host "Accès refusé : code incorrect."
}

Ton âge ?: 20
Ton code (1234) ?: 9999
Accès refusé : code incorrect.

7. Le switch : choisir parmi plein de cas

Quand tu dois tester la même variable contre beaucoup de valeurs, enchaîner les elseif devient lourd. Le switch fait ça plus proprement : « regarde cette valeur, et selon ce qu'elle vaut, fais le bon bloc ».

$jour = [int](Read-Host "Numéro du jour (1-7) ?")
switch ($jour) {
    1 { Write-Host "Lundi" }
    2 { Write-Host "Mardi" }
    3 { Write-Host "Mercredi" }
    4 { Write-Host "Jeudi" }
    5 { Write-Host "Vendredi" }
    6 { Write-Host "Samedi" }
    7 { Write-Host "Dimanche" }
    default { Write-Host "Numéro invalide (attendu 1 à 7)" }
}

Numéro du jour (1-7) ?: 3
Mercredi

8. Les listes (tableaux) : ranger plusieurs valeurs

Jusqu'ici, une variable contenait une valeur. Mais souvent tu veux en ranger plusieurs : la liste des visiteurs, des fichiers à traiter… C'est une liste (on dit aussi « tableau »).

Créer une liste et lire ses éléments

$visiteurs = @("Marc", "Sophie", "Karim")
Write-Host "Premier visiteur : $($visiteurs[0])"
Write-Host "Nombre de visiteurs : $($visiteurs.Count)"

Premier visiteur : Marc
Nombre de visiteurs : 3

Ajouter un élément

$visiteurs += "Lina"
Write-Host "Maintenant : $($visiteurs.Count) visiteurs"

Maintenant : 4 visiteurs

Parcourir toute la liste

foreach ($v in $visiteurs) {
    Write-Host "- $v"
}

- Marc
- Sophie
- Karim
- Lina

9. Les boucles sur des fichiers

La vraie puissance : faire la même action sur plein d'éléments réels — par exemple tous les fichiers d'un dossier. On combine une liste de fichiers et une boucle.

$fichiers = Get-ChildItem *.txt
foreach ($f in $fichiers) {
    Write-Host "Trouvé : $($f.Name)"
}

Trouvé : note.txt
Trouvé : moi.txt
Trouvé : rapport.txt

Les propriétés utiles d'un fichier (tableau de référence)

Exemple pro — nettoyer les logs de plus de 30 jours

Cas réel : un serveur GSB accumule des journaux d'application dans C:\Logs. Chaque nuit, un script supprime ceux de plus de 30 jours pour éviter de saturer le disque. C'est une des automatisations les plus demandées en entreprise.

# Nettoyage automatique des logs GSB (script pro)
$dossierLogs = "C:\Logs"
$limiteJours = 30
$dateButoir  = (Get-Date).AddDays(-$limiteJours)
$supprimés   = 0

Get-ChildItem -Path $dossierLogs -Filter *.log -File |
    Where-Object { $_.LastWriteTime -lt $dateButoir } |
    ForEach-Object {
        Remove-Item $_.FullName
        $supprimés++
    }

Write-Host "$supprimés log(s) supprimé(s) antérieurs au $($dateButoir.ToString('yyyy-MM-dd'))"

3 log(s) supprimé(s) antérieurs au 2026-08-03

10. D'autres boucles : compter et répéter

Le foreach parcourt une liste. Mais parfois on veut compter (de 1 à 10) ou répéter tant qu'une condition est vraie. Deux autres boucles pour ça.

La boucle for : compter

for ($i = 1; $i -le 5; $i++) {
    Write-Host "Tour numéro $i"
}

Tour numéro 1
Tour numéro 2
Tour numéro 3
Tour numéro 4
Tour numéro 5

La boucle while : tant que…

$compte = 3
while ($compte -gt 0) {
    Write-Host "Décollage dans $compte..."
    $compte = $compte - 1
}
Write-Host "Décollage !"

Décollage dans 3...
Décollage dans 2...
Décollage dans 1...
Décollage !

La boucle do…while : exécuter au moins une fois

Avec while, si la condition est fausse dès le départ, le bloc ne s'exécute jamais. do…while garantit un premier passage, puis vérifie la condition :

do {
    $reponse = Read-Host "Tape 'ok' pour continuer"
} while ($reponse -ne "ok")

Tape 'ok' pour continuer: non
Tape 'ok' pour continuer: peut-être
Tape 'ok' pour continuer: ok
(suite du script)

Générer une plage de nombres : 1..10

PowerShell a un raccourci pratique pour créer une suite de nombres sans écrire une boucle for :

# Afficher les nombres de 1 à 5
1..5 | ForEach-Object { Write-Host "Tour $_" }

# Créer 5 dossiers nommés "labo-1" à "labo-5"
1..5 | ForEach-Object { New-Item -ItemType Directory -Name "labo-$_" | Out-Null }
Write-Host "5 dossiers créés."

5 dossiers créés.

Tableau comparatif — quelle boucle choisir ?

11. Les fonctions : réutiliser un bloc

Quand tu fais plusieurs fois la même chose dans un script, tu ne réécris pas le code à chaque fois : tu en fais une fonction — un bloc nommé, que tu appelles autant que tu veux. C'est une brique majeure de la programmation.

Définir et appeler une fonction

function Saluer {
    param($nom)
    Write-Host "Bonjour $nom, bienvenue chez GSB !"
}

Saluer "Marc"
Saluer "Sophie"

Bonjour Marc, bienvenue chez GSB !
Bonjour Sophie, bienvenue chez GSB !

Une fonction qui RENVOIE un résultat

function CalculerTTC {
    param($prixHT)
    return $prixHT * 1.20
}

$total = CalculerTTC 100
Write-Host "Prix TTC : $total euros"

Prix TTC : 120 euros

Rendre les paramètres robustes : typage et obligation

Pour les scripts qu'on partage ou qu'on automatise, il faut que la fonction refuse de fonctionner si on lui passe n'importe quoi. PowerShell permet de typer les paramètres et de les rendre obligatoires :

function CalculerTVA {
    param(
        [Parameter(Mandatory=$true)]
        [double]$prixHT,

        [double]$tauxTVA = 0.20   # valeur par défaut = 20%
    )
    return [math]::Round($prixHT * (1 + $tauxTVA), 2)
}

CalculerTVA 100           # → 120.0  (taux par défaut)
CalculerTVA 100 0.055     # → 105.5  (TVA réduite 5,5%)
CalculerTVA               # → PowerShell demande le prixHT !

120
105.5
Fournissez des valeurs pour les paramètres suivants :
prixHT : 

Le return implicite — PowerShell est différent de C#

12. Donner des arguments au script lui-même

Jusqu'ici, soit ton script demandait les infos avec Read-Host, soit elles étaient écrites « en dur ». Mais un vrai outil de pro se lance avec ses infos dès la ligne de commande — comme Copy-Item source destination. Ces infos passées au lancement s'appellent des arguments.

param() en tête de script

Crée salut.ps1 avec, tout en haut (première instruction !) :

param($prenom, $ville)
Write-Host "Salut $prenom, tu viens de $ville !"

Lancer le script avec ses arguments

.\salut.ps1 Marc Lyon

Salut Marc, tu viens de Lyon !

Tu peux aussi nommer les arguments (l'ordre n'importe plus) :

.\salut.ps1 -ville Paris -prenom Sophie

Salut Sophie, tu viens de Paris !

Et si je ne sais pas combien d'arguments ? $args

# compte.ps1
Write-Host "Tu as passé $($args.Count) argument(s)."
foreach ($a in $args) {
    Write-Host "- $a"
}

PS> .\compte.ps1 pomme poire kiwi
Tu as passé 3 argument(s).
- pomme
- poire
- kiwi

13. Lire et écrire des fichiers dans un script

Un script devient vraiment puissant quand il traite des fichiers : lire une liste, écrire un journal (un « log »). C'est le quotidien de l'administration système.

Lire un fichier ligne par ligne

Crée d'abord un fichier visiteurs.txt avec quelques noms (un par ligne), puis :

$lignes = Get-Content visiteurs.txt
foreach ($ligne in $lignes) {
    Write-Host "Visiteur : $ligne"
}

Visiteur : Marc
Visiteur : Sophie
Visiteur : Karim

Écrire dans un journal (log) daté

$date = Get-Date -Format "yyyy-MM-dd HH:mm"
"[$date] Script lancé" | Add-Content journal.log

Les 4 cmdlets de fichiers — tableau complet

Lire un CSV structuré : Import-Csv

Un fichier CSV a des colonnes nommées. Get-Content renvoie des lignes brutes de texte que tu dois découper à la main avec -split. Import-Csv fait ça automatiquement et renvoie des objets dotés de propriétés nommées selon l'en-tête — le gain de temps est énorme.

Crée le fichier visiteurs.csv (Bloc-notes, colle ces lignes, enregistre) :

Prenom,Nom,Service
Marc,Dupont,Informatique
Sophie,Martin,Comptabilité
Karim,Benali,Direction

Lis-le avec Import-Csv :

$visiteurs = Import-Csv visiteurs.csv
foreach ($v in $visiteurs) {
    Write-Host "$($v.Prenom) $($v.Nom) — service : $($v.Service)"
}

Marc Dupont — service : Informatique
Sophie Martin — service : Comptabilité
Karim Benali — service : Direction

Get-Content vs Import-Csv — quand choisir quoi ?

14. Quand ça plante : lire l'erreur & déboguer

Tous les scripts plantent un jour. Ce qui fait le bon technicien, ce n'est pas de ne jamais se tromper : c'est de savoir lire l'erreur et la corriger calmement.

Décoder un message d'erreur

Set-Location : Impossible de trouver le chemin « C:\labo\absent »...
Au caractère C:\scripts\sauvegarde.ps1:6 : 5

La technique du « jalon » (tracer)

Quand un script fait un truc bizarre sans planter, sème des repères pour voir jusqu'où il va :

Write-Host "1 - avant la copie"
Copy-Item "$source\*" $destination -Recurse
Write-Host "2 - après la copie"

Attraper une erreur proprement : try / catch

try {
    Copy-Item "$source\*" $destination -Recurse
    Write-Host "Sauvegarde réussie."
} catch {
    Write-Host "Échec : $($_.Exception.Message)"
}

Contrôler le comportement sur erreur : $ErrorActionPreference

Par défaut, PowerShell affiche l'erreur en rouge mais continue l'exécution. Dans un script automatisé, c'est dangereux : si la copie rate, le script continue et « confirme » une sauvegarde qui n'a pas eu lieu.

# En haut du script, force l'arrêt immédiat sur toute erreur :
$ErrorActionPreference = "Stop"

try {
    Copy-Item "$source\*" $destination -Recurse
    Write-Host "Sauvegarde réussie."
} catch {
    Write-Host "ÉCHEC : $($_.Exception.Message)"
    exit 1   # code de retour 1 = erreur (utile pour les tâches planifiées)
}

Tester sans casser : -WhatIf

Beaucoup de cmdlets « destructifs » (Move-Item, Remove-Item, Copy-Item, Set-Content…) acceptent -WhatIf : ils simulent l'action et disent ce qu'ils auraient fait, sans rien toucher.

Remove-Item "*.log" -WhatIf

WhatIf : Opération « Suppression de l'élément » en cours sur la cible « C:\scripts\debug.log ».
WhatIf : Opération « Suppression de l'élément » en cours sur la cible « C:\scripts\journal.log ».

Tracer ce que fait un script : Write-Verbose

$VerbosePreference = "Continue"   # active les messages verbose

function SauvegarderDossier {
    param([string]$source)
    Write-Verbose "Vérification du dossier source : $source"
    if (-not (Test-Path $source)) {
        Write-Error "Dossier introuvable : $source"
        return
    }
    Write-Verbose "Démarrage de la copie..."
    Copy-Item $source "backup-$(Get-Date -Format 'yyyyMMdd')" -Recurse
    Write-Verbose "Copie terminée."
    Write-Host "Sauvegarde réussie."
}

Connaître son environnement : $PSVersionTable

Avant de déboguer, sache dans quelle version de PowerShell tu travailles. Les comportements varient entre PS 5.1 (intégré à Windows) et PS 7+ (à installer séparément) :

$PSVersionTable

Name                           Value
----                           -----
PSVersion                      5.1.19041.4291
PSEdition                      Desktop
BuildVersion                   10.0.19041.4291
CLRVersion                     4.0.30319.42000

Mode trace — suivre l'exécution ligne par ligne

Quand un script se comporte de façon inattendue et que tu ne sais pas quelle ligne est en cause, active le mode trace :

Set-PSDebug -Trace 1   # active : chaque ligne est affichée avant exécution
.\monscript.ps1
Set-PSDebug -Off       # désactive : revient au mode normal

DEBUG:    1+  >>>> $source = Read-Host "Quel dossier ?"
DEBUG:    2+  >>>> if (Test-Path $source) {
DEBUG:    3+  >>>>     Copy-Item "$source\*" $destination -Recurse

15. Un vrai script utile : la sauvegarde datée

On assemble tout pour résoudre le problème du début : sauvegarder un dossier dans une copie datée du jour. Voici le script complet, commenté.

# Sauvegarde datée d'un dossier — GSB
$source = Read-Host "Quel dossier sauvegarder ?"

if (Test-Path $source) {
    $date = Get-Date -Format "yyyy-MM-dd"
    $destination = "sauvegarde-$date"
    New-Item -ItemType Directory -Name $destination | Out-Null
    Copy-Item "$source\*" $destination -Recurse
    Write-Host "Sauvegarde de '$source' faite dans '$destination'."
} else {
    Write-Host "Le dossier '$source' n'existe pas. Abandon."
}

Version robuste — ce qu'on met en production

La version ci-dessus est pédagogique. Un script qui tourne seul toutes les nuits sans que personne le surveille doit gérer les pannes, journaliser ses actions et signaler les erreurs. Voici ce que devient ce script en conditions réelles :

# sauvegarde-robuste.ps1 — GSB production
param(
    [Parameter(Mandatory=$true)]
    [string]$source,
    [string]$racine = "C:\Sauvegardes"
)

$ErrorActionPreference = "Stop"
$date        = Get-Date -Format "yyyy-MM-dd_HHmm"
$destination = Join-Path $racine "sauvegarde-$date"
$log         = Join-Path $racine "sauvegarde.log"

function Journaliser {
    param([string]$msg)
    $h = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    "[$h] $msg" | Add-Content $log -Encoding UTF8
    Write-Host $msg
}

try {
    if (-not (Test-Path $source)) {
        throw "Dossier source introuvable : $source"
    }
    New-Item -ItemType Directory -Path $destination | Out-Null
    Copy-Item "$source\*" $destination -Recurse

    $nbFichiers = (Get-ChildItem $destination -Recurse -File).Count
    Journaliser "SUCCES — $nbFichiers fichier(s) dans $destination"
    exit 0
}
catch {
    Journaliser "ECHEC — $($_.Exception.Message)"
    exit 1
}

PS> .\sauvegarde-robuste.ps1 -source Documents
[2026-09-21 22:00:03] SUCCES — 47 fichier(s) dans C:\Sauvegardes\sauvegarde-2026-09-21_2200

16. Le même esprit côté Linux (bash)

Tout ce que tu viens d'apprendre existe aussi en bash, avec une syntaxe un peu différente. Apprendre l'un te donne 80 % de l'autre. Dans ta VM Linux, crée bonjour.sh :

#!/bin/bash
nom="GSB"
echo "Bonjour depuis le script $nom"

Le rendre exécutable, puis le lancer

chmod +x bonjour.sh
./bonjour.sh

Bonjour depuis le script GSB

Demander une info : read

#!/bin/bash
read -p "Ton prénom ? " prenom
echo "Bonjour $prenom !"

Ton prénom ? Marc
Bonjour Marc !

La condition en bash : if … then … fi

#!/bin/bash
read -p "Ton âge ? " age
if [ "$age" -ge 18 ]; then
    echo "Tu es majeur."
else
    echo "Tu es mineur."
fi

Ton âge ? 20
Tu es majeur.

La boucle for en bash

#!/bin/bash
for fichier in *.txt; do
    echo "Trouvé : $fichier"
done

Trouvé : note.txt
Trouvé : rapport.txt

Une fonction en bash

#!/bin/bash
saluer() {
    echo "Bonjour $1, bienvenue chez GSB !"
}

saluer "Marc"
saluer "Sophie"

Bonjour Marc, bienvenue chez GSB !
Bonjour Sophie, bienvenue chez GSB !

Les variables spéciales bash — ce que le script sait sur lui-même

#!/bin/bash
echo "Nom du script    : $0"
echo "Nbre d'arguments : $#"
echo "Tous les args    : $@"
echo "1er argument     : $1"
echo "Code retour préc : $?"

#!/bin/bash
cp "$1" "$2"
if [ $? -ne 0 ]; then
    echo "ERREUR : la copie a échoué."
    exit 1
fi
echo "Copie réussie."

ERREUR : la copie a échoué.

Vérifier le nombre d'arguments — réflexe de robustesse

#!/bin/bash
# sauvegarde.sh  source  destination
if [ $# -ne 2 ]; then
    echo "Usage : $0  "
    exit 1
fi
cp -r "$1" "$2"
echo "Copié : $1 → $2"

$ ./sauvegarde.sh documents
Usage : ./sauvegarde.sh <source> <destination>

Tableau comparatif complet — PowerShell vs bash

17. Mini-projet : ton assistant de rangement

Mission : un script PowerShell qui range automatiquement les fichiers d'un dossier par type, et fait un petit rapport. Tu vas réunir presque toutes les briques : argument/question, condition, switch, liste, boucle, compteur.

Le cahier des charges

1. Demande à l'utilisateur le dossier à ranger (Read-Host) — ou prends-le en argument (param).
2. Vérifie qu'il existe (if/Test-Path), sinon arrête avec un message.
3. Crée (s'ils n'existent pas) trois sous-dossiers : textes, images, autres.
4. Parcourt les fichiers (foreach) et déplace chacun selon son extension (.txt → textes, .jpg/.png → images, le reste → autres).
5. Affiche combien de fichiers ont été rangés.

18. Planifier l'exécution automatique

Écrire un script, c'est bien. Le faire tourner tout seul, sans intervention humaine, à heure fixe chaque nuit, c'est le vrai objectif de l'automatisation. Deux outils selon l'OS : le Gestionnaire de tâches (Windows) et cron (Linux).

Windows — Gestionnaire de tâches (Task Scheduler)

Le Gestionnaire de tâches (taskschd.msc en interface graphique) permet de lancer un programme à une heure précise, au démarrage, ou à intervalle fixe. En PowerShell, on le configure entièrement en ligne de commande — idéal pour l'automatiser sur 100 postes d'un coup.

# Planifier la sauvegarde GSB chaque nuit à 22h
$action = New-ScheduledTaskAction `
    -Execute "powershell.exe" `
    -Argument "-NonInteractive -File C:\scripts\sauvegarde-robuste.ps1 -source C:\Users\Public\Documents"

$trigger = New-ScheduledTaskTrigger -Daily -At "22:00"

$settings = New-ScheduledTaskSettingsSet `
    -ExecutionTimeLimit (New-TimeSpan -Hours 1) `
    -StartWhenAvailable

Register-ScheduledTask `
    -TaskName "GSB-Sauvegarde-Nuit" `
    -Action $action `
    -Trigger $trigger `
    -Settings $settings `
    -RunLevel Highest `
    -Force

TaskPath  TaskName             State    Enabled
--------  --------             -----    -------
\         GSB-Sauvegarde-Nuit  Ready    True

Gérer ses tâches planifiées en ligne de commande

Linux — cron et crontab

Sous Linux, c'est le démon cron qui gère les tâches planifiées. Chaque utilisateur a son crontab, un fichier de tâches édité avec crontab -e.

La syntaxe cron — 5 champs

#  min  heure  jour_du_mois  mois  jour_semaine   commande
   0    22     *             *     *              /bin/bash /home/marc/sauvegarde.sh

Ajouter sa première tâche cron

# Dans ta VM Linux
crontab -e

# Sauvegarde chaque jour à 22h — capture la sortie ET les erreurs dans le log
0 22 * * * /bin/bash /home/marc/sauvegarde.sh >> /home/marc/sauvegarde.log 2>&1

Commandes cron essentielles

Pour finir

Ton antisèche (les briques)

Chiffres-repères et limites pratiques

PowerShell, bash, ou Python — quand choisir quoi ?

Vérifie tes acquis

Nuances métier — ce qu'on ne te dit pas toujours

Glossaire