Gérer Git avec Visual Studio Code

8 novembre 202513 mai 2019 par scotch

Capture d'écran illustrant le social coding et la collaboration GitHub via Visual Studio Code

Visual Studio Code est un IDE Open Source qui gère une impressionnante liste de langage de programmation. Il intègre une gestion de plugin avec une bibliothèque très complète.

La gestion de Git est intégrée à VSC.

Bonnes pratiques

Quand vous allez créer un repositorie, automatiquement la branch Master est créé.

Je conseil de créer une branch Develop pour travailler uniquement dessus, puis de « Merger » vers la Master quand vous avez une version stable.

Script Powershell – Tester des flux TCP/UDP entre deux Windows

8 novembre 202512 avril 2019 par scotch

Capture d'écran d'un réseau informatique illustrant l'automatisation des tests TCP/UDP via PowerShell

Dans le cadre d’un nouveau projet, la vérification d’ouverture de flux réseau est important pour le bon fonctionnement de la communication entre serveurs.

Ce script vous permet de tester les flux entre deux machines. Exécuter le script sur les deux machines, l’un en mode client l’autre en mode serveur.

Le temps d’attente d’une requête est de 10s.

##############################################################################
#.DESCRIPTION
# Jean-Baptiste MERVEILLE
# https://laboiteajb.fr
#
# Script permetant de tester des flux reseau TCP/UDP
# Ce script ouvre des Socket TCP et UDP
#
##############################################################################

Clear-Host
# |F|O|N|C|T|I|O|N| |S|E|R|V|E|R| |U|D|P| #
Function StartSrvUDP
{
    Param (
        $Port,
        $ReturnUDP
    )
    Write-Host "Demarrage du serveur UDP $Port"
    #Initialisation.
    $ReturnUDP = ""

    #Création d'un objet EndPoint.
    $endpoint2 = new-object System.Net.IPEndPoint ([IPAddress]::Any,$Port)

    #Création d'un objet Socket UDP.
    $socudp2 = new-Object System.Net.Sockets.UdpClient $Port

    #Définition du TimeOut
    $socudp2.Client.ReceiveTimeout = 10000

    Try {
        #Attent l'arrivée des données.
        $encode2 = $socudp2.Receive([ref]$endpoint2)
    } Catch {
        #Affichage du message d'erreur
        Write-Warning "$($Error[0].Exception.InnerException.SocketErrorCode)"
        $TmpError = "$($Error[0].Exception.InnerException.SocketErrorCode)"
    }
    Try {
        #Converti les données reçues.
        $ReturnUDP  = [Text.Encoding]::ASCII.GetString($encode2)
    } Catch {
        #Affiche un message d'erreur si il y à pas de TimedOut
        if ($null -eq $($Error[0].Exception.InnerException.InnerException) -and $TmpError -ne "TimedOut") 
        {Write-Warning "Aucunes donees recus"}
    }
    
    #Fermeture.
    $socudp2.Close()

    #Fin. 
    Return $ReturnUDP
}
# |F|I|N| |D|E| |L|A| |F|O|N|C|T|I|O|N| |S|E|R|V|E|R| |U|D|P| #

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

# |F|O|N|C|T|I|O|N| |S|E|R|V|E|R| |T|C|P| #
function StartSrvTCP
{
    Param (
        $Port,
        $ReturnTCP
    )
    #Initialisation de la variable
    $Buffer = ""

    #Creation d'un Job
    $Job = Start-Job -ArgumentList $port -Name "StartSrvTCP" -ScriptBlock {
            #Récuperation de la varible $port pour l'utiliser dans le job
            $port = $args[0]

            #Paramétrage du TcpListener
            $server = New-Object -TypeName System.Net.Sockets.TcpListener -ArgumentList @([System.Net.IPAddress]::Any, $port)
            
            #Démarrage de l'ecoute
            $server.Start()
            
            Write-Host "Listening on port $port"

            #Accepte une demande de connexion en attente.
            $clientSocket = $server.AcceptSocket()

            #Paramétrage du buffer
            $buffer = new-object System.Byte[] 2048;

            #Réception des données
            $clientSocket.Receive($buffer) 

            ##Converti les données reçues.
            $ReturnTCP = [System.Text.Encoding]::ASCII.GetString($Buffer)

            #Fermeture du socket
            $clientSocket.Close()
        
            #Arret de l'ecoute 
            $server.Stop()

            # Retour du resultat
            Return $ReturnTCP
    }
    #Fin du Job

    #Timeout de 10s
    Wait-Job -Id $job.Id -Timeout 10

    Write-Host "Stopped Listening"

    #Retour des infos
    Return (Get-Job -Id $job.Id | Receive-Job)
   
}
# |F|I|N| |D|E| |L|A| |F|O|N|C|T|I|O|N| |S|E|R|V|E|R| |T|C|P| #

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

# |F|O|N|C|T|I|O|N| |C|L|I|E|N|T| |U|D|P| #
function StartClientUDP
{
    Param (
        $Port,
        $ReturnUDP,
        $IP
    )
            #Récuperation du nom de l'hote
            $hostname = $env:computername

            #Récuperation de l'IP
            $ipV4 = Test-Connection -ComputerName (hostname) -Count 1  | Select IPV4Address
            $ipV4 = $ipV4.IPV4Address.IPAddressToString

            Write-Host "Emission des donnees sur le reseau. Port UDP : $Port"

            #Ip du destinataire.
            $ippc1 = [System.Net.Dns]::GetHostAddresses($IP)

            #Texte à envoyer.
            $SendText = "Test du $hostname ($ipV4) -> $IP Port UDP: $Port reussi"

            #Création d'un objet EndPoint.
            $endpoint1 = new-object System.Net.IPEndPoint ([IPAddress]$ippc1[0],$Port)

            #Création d'un objet Socket UDP.
            $SocUDP = new-Object System.Net.Sockets.UdpClient

            #Préparation du text à l'envoi.
            $SendText = [Text.Encoding]::ASCII.GetBytes($SendText)

            #Envoie du message.
            $SocUDP.Send($SendText,$SendText.length,$endpoint1) | Out-Null

            #Fermeture.
            $SocUDP.Close()
}
# |F|I|N| |D|E| |L|A| |F|O|N|C|T|I|O|N| |C|L|I|E|N|T| |U|D|P| #

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

# |F|O|N|C|T|I|O|N| |C|L|I|E|N|T| |T|C|P| #
function StartClientTCP
{
    Param (
        $Port,
        $ReturnTCP,
        $IP
    )    
                #Récuperation du nom de l'hote
                $hostname = $env:computername

                #Récuperation de l'IP
                $ipV4 = Test-Connection -ComputerName (hostname) -Count 1  | Select IPV4Address
                $ipV4 = $ipV4.IPV4Address.IPAddressToString
                
                Write-Host "Emission des donnees sur le reseau. Port TCP : $Port"

                #Ip du destinataire.
                $ippc1 = [System.Net.Dns]::GetHostAddresses($IP)

                #Texte à envoyer.
                $SendText = "Test du $hostname ($ipV4) -> $IP Port TCP: $Port reussi"

                #Création d'un objet Socket TCP.
                $SocTCP = New-Object -TypeName System.Net.Sockets.TcpClient -ArgumentList $IP,$port
                
                #Retourne le NetworkStream utilisé pour l'envoi et la réception de données.
                $stream = $SocTCP.GetStream()
                
                #Préparation du text à l'envoi.
                $buffer = [System.Text.Encoding]::ASCII.GetBytes($SendText)
                $ReturnTCP = [System.Text.Encoding]::ASCII.GetString($Buffer)
                
                #Envoie du message.
                $stream.Write($buffer, 0, $buffer.Length)

                #Fermeture.
                $stream.Close()
                $SocTCP.Close()
}
# |F|I|N| |D|E| |L|A| |F|O|N|C|T|I|O|N| |C|L|I|E|N|T| |T|C|P| #

# |M|E|N|U| #
do {
    do {
        write-host ""
        write-host "U - Serveur UDP"
        write-host "T - Serveur TCP"
        write-host "A - Client UDP"
        write-host "B - Client TCP"
        write-host ""
        write-host "X - Exit"
        write-host ""
        write-host -nonewline "Tapez votre choix et appuyez sur Entree: "
        
        $choice = read-host
        
        write-host ""
        
        $ok = $choice -match '^[abutx]+$'
        
        if ( -not $ok) { write-host "Choix invalide !" }
    } until ( $ok )
    
    switch -Regex ( $choice ) {
        "U"
        # SERVEUR UDP #
        {
            write-host "Serveur UDP"

            $Port=Read-Host "Entrer le numero de port UDP"

            # Vérification du port, si le port n'est pas utilisé $CheckPort est null
            $CheckPort = Get-NetUDPEndpoint -LocalPort $Port -ErrorAction SilentlyContinue
            if ($null -eq $CheckPort)
                {Write-Information "Le port n'est pas utilise"
                #Démarrage du Serveur UDP
                $ReturnUDP = StartSrvUDP -Port $Port
                Write-Host $ReturnUDP -ForegroundColor green
                }

            else {
                Write-Warning "Le port $Port est utilise, impossible de tester !"
            }



        }
        
        "T"
        # SERVEUR TCP #
        {
            write-host "Serveur TCP"
            $Port=Read-Host "Entrer le numero de port TCP"

            # Vérification du port, si le port n'est pas utilisé $CheckPort est null
            $CheckPort = Get-NetTCPConnection -LocalPort $Port -ErrorAction SilentlyContinue
            if ($null -eq $CheckPort)
                {Write-Information "Le port n'est pas utilise"
                #Démarrage du Serveur TCP
                $ReturnTCP = StartSrvTCP -Port $Port -ErrorAction SilentlyContinue
                if ($null -eq $ReturnTCP) 
                    {Write-Warning "!! Time Out !!"
                    
                    #Envoie d'une requete pour liberer le socket
                    Write-Warning "Envoie d'une requete local pour liberer le socket"
                    StartClientTCP -Port $Port -IP "127.0.0.1"
                    }
                else {Write-Host $ReturnTCP[2] -ForegroundColor green}

                
                }

            else {
                Write-Warning "Le port $Port est utilise, impossible de tester !"
            }



        }

        "A"
        # CLIENT UDP #
        {
            write-host "Client UDP"

            #Port de communication.
            $Port=Read-Host "Entrer le numero de port UDP"
            $IP=Read-Host "Entrer l'IP de destination"

            #Démarrage du Serveur UDP
            $ReturnUDP = StartClientUDP -Port $Port -IP $IP
            Write-Host $ReturnUDP -ForegroundColor green
           
        }
        
        "B"
        # CLIENT TCP #
        {
            write-host "Client TCP"
            
            $Port=Read-Host "Entrer le numero de port TCP"
            $IP=Read-Host "Entrer l'IP de destination"
            
            #Démarrage du Serveur TCP
            $ReturnTCP = StartClientTCP -Port $Port -IP $IP
            Write-Host $ReturnTCP -ForegroundColor green
        }
    }
} until ( $choice -match "X" )

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

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

#.DESCRIPTION

# Jean-Baptiste MERVEILLE

# https://laboiteajb.fr

# Script permetant de tester des flux reseau TCP/UDP

# Ce script ouvre des Socket TCP et UDP

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

Clear-Host

# |F|O|N|C|T|I|O|N| |S|E|R|V|E|R| |U|D|P| #

Function StartSrvUDP

{

Param (

$Port,

$ReturnUDP

)

Write-Host "Demarrage du serveur UDP $Port"

#Initialisation.

$ReturnUDP = ""

#Création d'un objet EndPoint.

$endpoint2 = new-object System.Net.IPEndPoint ([IPAddress]::Any,$Port)

#Création d'un objet Socket UDP.

$socudp2 = new-Object System.Net.Sockets.UdpClient $Port

#Définition du TimeOut

$socudp2.Client.ReceiveTimeout = 10000

Try {

#Attent l'arrivée des données.

$encode2 = $socudp2.Receive([ref]$endpoint2)

} Catch {

#Affichage du message d'erreur

Write-Warning "$($Error[0].Exception.InnerException.SocketErrorCode)"

$TmpError = "$($Error[0].Exception.InnerException.SocketErrorCode)"

}

Try {

#Converti les données reçues.

$ReturnUDP = [Text.Encoding]::ASCII.GetString($encode2)

} Catch {

#Affiche un message d'erreur si il y à pas de TimedOut

if ($null -eq $($Error[0].Exception.InnerException.InnerException) -and $TmpError -ne "TimedOut")

{Write-Warning "Aucunes donees recus"}

}

#Fermeture.

$socudp2.Close()

#Fin.

Return $ReturnUDP

}

# |F|I|N| |D|E| |L|A| |F|O|N|C|T|I|O|N| |S|E|R|V|E|R| |U|D|P| #

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

# |F|O|N|C|T|I|O|N| |S|E|R|V|E|R| |T|C|P| #

function StartSrvTCP

{

Param (

$Port,

$ReturnTCP

)

#Initialisation de la variable

$Buffer = ""

#Creation d'un Job

$Job = Start-Job -ArgumentList $port -Name "StartSrvTCP" -ScriptBlock {

#Récuperation de la varible $port pour l'utiliser dans le job

$port = $args[0]

#Paramétrage du TcpListener

$server = New-Object -TypeName System.Net.Sockets.TcpListener -ArgumentList @([System.Net.IPAddress]::Any, $port)

#Démarrage de l'ecoute

$server.Start()

Write-Host "Listening on port $port"

#Accepte une demande de connexion en attente.

$clientSocket = $server.AcceptSocket()

#Paramétrage du buffer

$buffer = new-object System.Byte[] 2048;

#Réception des données

$clientSocket.Receive($buffer)

##Converti les données reçues.

$ReturnTCP = [System.Text.Encoding]::ASCII.GetString($Buffer)

#Fermeture du socket

$clientSocket.Close()

#Arret de l'ecoute

$server.Stop()

# Retour du resultat

Return $ReturnTCP

}

#Fin du Job

#Timeout de 10s

Wait-Job -Id $job.Id -Timeout 10

Write-Host "Stopped Listening"

#Retour des infos

Return (Get-Job -Id $job.Id | Receive-Job)

}

# |F|I|N| |D|E| |L|A| |F|O|N|C|T|I|O|N| |S|E|R|V|E|R| |T|C|P| #

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

# |F|O|N|C|T|I|O|N| |C|L|I|E|N|T| |U|D|P| #

function StartClientUDP

{

Param (

$Port,

$ReturnUDP,

$IP

)

#Récuperation du nom de l'hote

$hostname = $env:computername

#Récuperation de l'IP

$ipV4 = Test-Connection -ComputerName (hostname) -Count 1 | Select IPV4Address

$ipV4 = $ipV4.IPV4Address.IPAddressToString

Write-Host "Emission des donnees sur le reseau. Port UDP : $Port"

#Ip du destinataire.

$ippc1 = [System.Net.Dns]::GetHostAddresses($IP)

#Texte à envoyer.

$SendText = "Test du $hostname ($ipV4) -> $IP Port UDP: $Port reussi"

#Création d'un objet EndPoint.

$endpoint1 = new-object System.Net.IPEndPoint ([IPAddress]$ippc1[0],$Port)

#Création d'un objet Socket UDP.

$SocUDP = new-Object System.Net.Sockets.UdpClient

#Préparation du text à l'envoi.

$SendText = [Text.Encoding]::ASCII.GetBytes($SendText)

#Envoie du message.

$SocUDP.Send($SendText,$SendText.length,$endpoint1) | Out-Null

#Fermeture.

$SocUDP.Close()

}

# |F|I|N| |D|E| |L|A| |F|O|N|C|T|I|O|N| |C|L|I|E|N|T| |U|D|P| #

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

# |F|O|N|C|T|I|O|N| |C|L|I|E|N|T| |T|C|P| #

function StartClientTCP

{

Param (

$Port,

$ReturnTCP,

$IP

)

#Récuperation du nom de l'hote

$hostname = $env:computername

#Récuperation de l'IP

$ipV4 = Test-Connection -ComputerName (hostname) -Count 1 | Select IPV4Address

$ipV4 = $ipV4.IPV4Address.IPAddressToString

Write-Host "Emission des donnees sur le reseau. Port TCP : $Port"

#Ip du destinataire.

$ippc1 = [System.Net.Dns]::GetHostAddresses($IP)

#Texte à envoyer.

$SendText = "Test du $hostname ($ipV4) -> $IP Port TCP: $Port reussi"

#Création d'un objet Socket TCP.

$SocTCP = New-Object -TypeName System.Net.Sockets.TcpClient -ArgumentList $IP,$port

#Retourne le NetworkStream utilisé pour l'envoi et la réception de données.

$stream = $SocTCP.GetStream()

#Préparation du text à l'envoi.

$buffer = [System.Text.Encoding]::ASCII.GetBytes($SendText)

$ReturnTCP = [System.Text.Encoding]::ASCII.GetString($Buffer)

#Envoie du message.

$stream.Write($buffer, 0, $buffer.Length)

#Fermeture.

$stream.Close()

$SocTCP.Close()

}

# |F|I|N| |D|E| |L|A| |F|O|N|C|T|I|O|N| |C|L|I|E|N|T| |T|C|P| #

# |M|E|N|U| #

do {

write-host ""

write-host "U - Serveur UDP"

write-host "T - Serveur TCP"

write-host "A - Client UDP"

write-host "B - Client TCP"

write-host ""

write-host "X - Exit"

write-host ""

write-host -nonewline "Tapez votre choix et appuyez sur Entree: "

$choice = read-host

write-host ""

$ok = $choice -match '^[abutx]+$'

if ( -not $ok) { write-host "Choix invalide !" }

} until ( $ok )

switch -Regex ( $choice ) {

"U"

# SERVEUR UDP #

{

write-host "Serveur UDP"

$Port=Read-Host "Entrer le numero de port UDP"

# Vérification du port, si le port n'est pas utilisé $CheckPort est null

$CheckPort = Get-NetUDPEndpoint -LocalPort $Port -ErrorAction SilentlyContinue

if ($null -eq $CheckPort)

{Write-Information "Le port n'est pas utilise"

#Démarrage du Serveur UDP

$ReturnUDP = StartSrvUDP -Port $Port

Write-Host $ReturnUDP -ForegroundColor green

}

else {

Write-Warning "Le port $Port est utilise, impossible de tester !"

}

"T"

# SERVEUR TCP #

{

write-host "Serveur TCP"

$Port=Read-Host "Entrer le numero de port TCP"

# Vérification du port, si le port n'est pas utilisé $CheckPort est null

$CheckPort = Get-NetTCPConnection -LocalPort $Port -ErrorAction SilentlyContinue

if ($null -eq $CheckPort)

{Write-Information "Le port n'est pas utilise"

#Démarrage du Serveur TCP

$ReturnTCP = StartSrvTCP -Port $Port -ErrorAction SilentlyContinue

if ($null -eq $ReturnTCP)

{Write-Warning "!! Time Out !!"

#Envoie d'une requete pour liberer le socket

Write-Warning "Envoie d'une requete local pour liberer le socket"

StartClientTCP -Port $Port -IP "127.0.0.1"

}

else {Write-Host $ReturnTCP[2] -ForegroundColor green}

}

else {

Write-Warning "Le port $Port est utilise, impossible de tester !"

}

"A"

# CLIENT UDP #

{

write-host "Client UDP"

#Port de communication.

$Port=Read-Host "Entrer le numero de port UDP"

$IP=Read-Host "Entrer l'IP de destination"

#Démarrage du Serveur UDP

$ReturnUDP = StartClientUDP -Port $Port -IP $IP

Write-Host $ReturnUDP -ForegroundColor green

}

"B"

# CLIENT TCP #

{

write-host "Client TCP"

$Port=Read-Host "Entrer le numero de port TCP"

$IP=Read-Host "Entrer l'IP de destination"

#Démarrage du Serveur TCP

$ReturnTCP = StartClientTCP -Port $Port -IP $IP

Write-Host $ReturnTCP -ForegroundColor green

}

} until ( $choice -match "X" )

Connexion d’un VPN à l’ouverture d’une application

16 mai 201911 janvier 2019 par scotch

Capture d'écran PowerShell pour automatiser les connexions VPN avec script et interface technique

Imaginons que nous avons une application métier. Cette application peut fonctionner uniquement sur le VPN de l’entreprise. Le soucis est que l’utilisateur doit à chaque fois, démarrer son VPN avant de lancer l’application.

Une commande powershell peut éviter cela : Add-VpnConnectionTriggerApplication

Fermer l’application et déconnecter le VPN.

Ouvrir une console Powershell et taper Get-VpnConnection afin de récupérer la valeur « Name »

Pour ajouter un trigger, taper la commande suivante : Add-VPNConnectionTriggerApplication -Name « Nom_des_la_Cnx_VPN » -ApplicationID « C:\Program Files\Mon_Application.exe » -Passthru ConnectionName : Nom_des_la_Cnx_VPN ApplicationID : {C:\Program Files\Mon_Application.exe}

Source : Microsoft

Ubuntu, sécuriser l’accès réseau via le firewall

16 mai 201911 janvier 2019 par scotch

Capture d'écran de la configuration iptables pour automatiser la sécurité réseau sous Linux

Par défaut sur un Ubuntu serveur, le firewall est activé, mais aucune règle n’est défini. Cela veut dire que l’ensemble du trafic rentre et sort sans restriction.

Le firewall est gérer par Iptables. Sont paramétrage est complexe, mais Ubuntu propose un logiciel simplifié, ufw.

Les bases

Sur un serveur fraîchement installé, commençons par afficher les règles actuelles.

sudo iptables -s

INPUT ACCEPT = le trafic entrant est accepté

FORWARD ACCEPT = le trafic de routage est accepté. Exemple un paquet qui provient d’un point A, qui entre par une carte réseau et qui sort d’une autre carte réseau pour aller au point B.

OUTPUT ACCEPT = le trafic sortant est accepté

Les PPKG

16 mai 20194 janvier 2019 par scotch

Capture d'écran PPKG : interface d'automatisation des packages de configuration Windows

Les .ppkg sont des packages d’approvisionnement. Ils offrent la possibilité de paramétrer Windows 10 en un seul fichier. Vous pouvez les intégrer directement dans un master ou en double cliquant sur le fichier. Le Concepteur de configuration Windows est disponible via l’ADK.

1 – Installation de ADK

2 – Création d’un package d’approvisionnement

3 – Application d’un package d’approvisionnement

4 – Dans quel cas l’utiliser ?

1 – Installation de ADK

Aller sur le site de Microsoft, télécharger et exécuter le setup de l’ADK

Cliquer sur Suivant

Assistance à distance

16 mai 20193 janvier 2019 par scotch

Capture d’écran d’une interface d’automatisation pour l’assistance technique à distance avec workflow et outils

TeamViewer, AnyDesk, LogMeIn … Pourquoi ne pas utiliser l’outil intégré à Windows 10 ?

Taper Assistance rapide dans le menu démarrer

Sur le PC invité (celui qui va dépanner) cliquer sur Aider un autre utilisateur

Personnaliser le menu démarrer de Windows 1O

4 janvier 20193 janvier 2019 par scotch

Capture d'écran du tutoriel pour personnaliser le Menu Démarrer Windows 10 via PowerShell et outils natifs

Sous Windows 10, il est possible de configurer par défaut les applications épinglées dans le menu démarrer. Cela est utile pour la personnalisation de vos pc.

De plus, vous pouvez l’administrer par GPO ou directement dans votre master.

1 – Exporter la configuration

2 – Importer la configuration

1 – Exporter la configuration

Sur une machine modèle, épingler les applications et la disposition comme vous le souhaité.

Ouvrir une console Powershell en tant qu’administrateur

Moniteur de fiabilité sous Windows 10

16 mai 20193 janvier 2019 par scotch

Capture d'écran du Moniteur de fiabilité Windows 10 pour analyser les plantages et erreurs système

Pour dépanner un PC, nous utilisons régulièrement les journaux événements de Windows. Mais sans savoir quoi chercher, nous passons la plupart du temps à scroller les événements.

Depuis Windows Seven, Microsoft a implanté un outil de diagnostique qui va vous aider un repérer le problème le plus facilement.

Dans le menu démarrer, taper Moniteur de fiabilité

La courbe bleu indique le taux de fiabilité
Les croix rouges indiquent les erreurs critiques
Les « I » bleu indique les événements systèmes
Les triangles jaunes indiquent les avertissements

Les sauvegardes sous Windows 10 en ligne de commande

16 mai 20193 janvier 2019 par scotch

Capture d'écran de WBAdmin pour automatiser les sauvegardes système Windows 10 via CMD

Nous avons vu dernièrement comment gérer les sauvegardes sous Windows 10 avec l’interface graphique. En réalité, c’est l’outil wbadmin.exe qui est utilisé en arrière plan.

Prérequis: Un deuxième disque dur doit être connecté sur la machine.

Sauvegarde

Commencer par ouvrir une Invite de commande en tant qu’administrateur

Pour lancer la sauvegarde, taper la commande

Les sauvegardes sous Windows 10

16 mai 201919 décembre 2018 par scotch

Capture d'écran de l'outil de sauvegarde de données Windows 10, automatisation et gestion des sauvegardes

Depuis Windows 7, Microsoft propose des outils de sauvegarde de fichier et du système.

Les sauvegardes automatiques des fichiers utilisateurs.

Minimum requis: un deuxième disque dur ou un emplacement réseau

Les sauvegardes

Taper « Sauvegarde » dans le menu démarrer et cliquer sur Paramètres de sauvegarde