Guide d'Ouverture de Ports sur VPS Windows
Published on November 11, 2025 at 02:56 PM
Guide complet d'ouverture de ports sur VPS Windows via le Pare-feu Windows Defender. Ce tutoriel détaille la configuration via l'interface graphique et PowerShell, la création de règles de trafic entrant/sortant, la gestion des protocoles TCP/UDP, et des exemples pour serveurs web, jeux, FTP et bases de données.
# Guide d'Ouverture de Ports sur VPS Windows
## Introduction
L'ouverture de ports sur un VPS Windows est une étape essentielle pour permettre aux applications et services de communiquer avec l'extérieur. Ce guide vous accompagne dans la configuration complète du pare-feu Windows pour ouvrir les ports nécessaires.
## Qu'est-ce qu'un Port ?
Un port est un point d'entrée virtuel sur votre serveur qui permet aux applications de communiquer via le réseau. Chaque service utilise un ou plusieurs ports spécifiques :
- **Port 80** : HTTP (sites web)
- **Port 443** : HTTPS (sites web sécurisés)
- **Port 3389** : Bureau à distance (RDP)
- **Port 21** : FTP
- **Port 22** : SSH
- **Port 25565** : Minecraft
- **Port 27015** : Source (CS:GO, etc.)
## Prérequis
Avant de commencer, assurez-vous d'avoir :
- Accès administrateur à votre VPS Windows
- Connexion Bureau à distance (RDP) active
- Les numéros de ports que vous souhaitez ouvrir
- Le protocole utilisé (TCP, UDP, ou les deux)
## Partie 1 : Ouverture de Ports via l'Interface Graphique
### Méthode 1 : Via le Pare-feu Windows Defender
#### Étape 1 : Ouvrir le Pare-feu Windows
**Option A : Via le menu Démarrer**
1. Cliquez sur le bouton **Démarrer**
2. Tapez **Pare-feu Windows Defender**
3. Cliquez sur **Pare-feu Windows Defender avec fonctions avancées de sécurité**
**Option B : Via l'exécution**
1. Appuyez sur `Windows + R`
2. Tapez : `wf.msc`
3. Appuyez sur **Entrée**
#### Étape 2 : Créer une Règle de Trafic Entrant
Le trafic entrant permet aux connexions externes d'accéder à votre serveur.
1. Dans le Pare-feu Windows, cliquez sur **Règles de trafic entrant** dans le panneau de gauche
2. Dans le panneau de droite, cliquez sur **Nouvelle règle...**
3. **Type de règle** :
- Sélectionnez **Port**
- Cliquez sur **Suivant**
4. **Protocole et ports** :
- Sélectionnez le protocole :
- **TCP** : Pour la plupart des applications web et jeux
- **UDP** : Pour les jeux, VoIP, streaming
- Sélectionnez **Ports locaux spécifiques**
- Entrez le numéro de port (exemple : `8080`)
- Pour plusieurs ports : `80,443,8080`
- Pour une plage : `25565-25575`
- Cliquez sur **Suivant**
5. **Action** :
- Sélectionnez **Autoriser la connexion**
- Cliquez sur **Suivant**
6. **Profil** :
- Cochez les trois options :
- ☑ Domaine
- ☑ Privé
- ☑ Public
- Cliquez sur **Suivant**
7. **Nom** :
- **Nom** : Donnez un nom descriptif (exemple : "Serveur Web HTTP")
- **Description** : Ajoutez une description (optionnel)
- Cliquez sur **Terminer**
#### Étape 3 : Créer une Règle de Trafic Sortant (Optionnel)
Le trafic sortant permet à votre serveur de se connecter à l'extérieur.
1. Cliquez sur **Règles de trafic sortant** dans le panneau de gauche
2. Suivez les mêmes étapes que pour le trafic entrant
**Note** : Par défaut, le trafic sortant est généralement autorisé. Cette étape n'est nécessaire que si vous avez des restrictions spécifiques.
### Méthode 2 : Via les Paramètres Windows (Simplifié)
Pour une configuration plus simple (Windows 10/11/Server 2019+) :
#### Étape 1 : Ouvrir les Paramètres du Pare-feu
1. Cliquez sur **Démarrer**
2. Allez dans **Paramètres** (icône d'engrenage)
3. Cliquez sur **Réseau et Internet**
4. Cliquez sur **Pare-feu Windows Defender**
5. Cliquez sur **Paramètres avancés**
Vous arrivez dans le même écran que la Méthode 1.
## Partie 2 : Ouverture de Ports via PowerShell
PowerShell permet d'ouvrir des ports rapidement via des commandes.
### Ouvrir PowerShell en Administrateur
1. Cliquez sur **Démarrer**
2. Tapez **PowerShell**
3. Faites un clic droit sur **Windows PowerShell**
4. Sélectionnez **Exécuter en tant qu'administrateur**
### Commandes de Base
#### Ouvrir un Port TCP
```powershell
New-NetFirewallRule -DisplayName "Nom de la Règle" -Direction Inbound -LocalPort 8080 -Protocol TCP -Action Allow
```
**Exemple : Ouvrir le port 80 (HTTP)**
```powershell
New-NetFirewallRule -DisplayName "HTTP Port 80" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow
```
#### Ouvrir un Port UDP
```powershell
New-NetFirewallRule -DisplayName "Nom de la Règle" -Direction Inbound -LocalPort 27015 -Protocol UDP -Action Allow
```
**Exemple : Ouvrir le port 25565 (Minecraft)**
```powershell
New-NetFirewallRule -DisplayName "Minecraft Server" -Direction Inbound -LocalPort 25565 -Protocol UDP -Action Allow
```
#### Ouvrir un Port TCP et UDP
Pour ouvrir le même port pour les deux protocoles :
```powershell
New-NetFirewallRule -DisplayName "Port 25565 TCP" -Direction Inbound -LocalPort 25565 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "Port 25565 UDP" -Direction Inbound -LocalPort 25565 -Protocol UDP -Action Allow
```
#### Ouvrir Plusieurs Ports
Pour ouvrir plusieurs ports d'un coup :
```powershell
New-NetFirewallRule -DisplayName "Ports Multiples" -Direction Inbound -LocalPort 80,443,8080 -Protocol TCP -Action Allow
```
#### Ouvrir une Plage de Ports
```powershell
New-NetFirewallRule -DisplayName "Plage Ports FTP Passif" -Direction Inbound -LocalPort 49152-65535 -Protocol TCP -Action Allow
```
### Commandes Avancées
#### Autoriser un Port pour une IP Spécifique
```powershell
New-NetFirewallRule -DisplayName "SSH depuis IP spécifique" -Direction Inbound -LocalPort 22 -Protocol TCP -Action Allow -RemoteAddress 203.0.113.10
```
#### Autoriser un Port pour un Programme Spécifique
```powershell
New-NetFirewallRule -DisplayName "Application Serveur" -Direction Inbound -Program "C:\MonServeur\serveur.exe" -Action Allow
```
#### Créer une Règle avec Profil Spécifique
```powershell
New-NetFirewallRule -DisplayName "Port Public" -Direction Inbound -LocalPort 8080 -Protocol TCP -Action Allow -Profile Public
```
Profils disponibles : `Domain`, `Private`, `Public`, ou `Any`
## Partie 3 : Exemples de Configurations Courantes
### Serveur Web (HTTP/HTTPS)
**Via PowerShell** :
```powershell
# HTTP
New-NetFirewallRule -DisplayName "HTTP Web Server" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow
# HTTPS
New-NetFirewallRule -DisplayName "HTTPS Web Server" -Direction Inbound -LocalPort 443 -Protocol TCP -Action Allow
```
### Serveur FTP
```powershell
# Port de contrôle FTP
New-NetFirewallRule -DisplayName "FTP Control" -Direction Inbound -LocalPort 21 -Protocol TCP -Action Allow
# Ports passifs FTP (plage standard)
New-NetFirewallRule -DisplayName "FTP Passive Ports" -Direction Inbound -LocalPort 49152-65535 -Protocol TCP -Action Allow
```
### Serveur de Jeux
**Minecraft** :
```powershell
# Port principal
New-NetFirewallRule -DisplayName "Minecraft TCP" -Direction Inbound -LocalPort 25565 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "Minecraft UDP" -Direction Inbound -LocalPort 25565 -Protocol UDP -Action Allow
# Port RCON (optionnel)
New-NetFirewallRule -DisplayName "Minecraft RCON" -Direction Inbound -LocalPort 25575 -Protocol TCP -Action Allow
```
**Rust** :
```powershell
# Port principal
New-NetFirewallRule -DisplayName "Rust Server TCP" -Direction Inbound -LocalPort 28015 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "Rust Server UDP" -Direction Inbound -LocalPort 28015 -Protocol UDP -Action Allow
# Port RCON
New-NetFirewallRule -DisplayName "Rust RCON" -Direction Inbound -LocalPort 28016 -Protocol TCP -Action Allow
```
**Counter-Strike/Source** :
```powershell
New-NetFirewallRule -DisplayName "Source Server TCP" -Direction Inbound -LocalPort 27015 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "Source Server UDP" -Direction Inbound -LocalPort 27015 -Protocol UDP -Action Allow
```
### Serveur de Base de Données
**MySQL/MariaDB** :
```powershell
New-NetFirewallRule -DisplayName "MySQL Server" -Direction Inbound -LocalPort 3306 -Protocol TCP -Action Allow
```
**PostgreSQL** :
```powershell
New-NetFirewallRule -DisplayName "PostgreSQL Server" -Direction Inbound -LocalPort 5432 -Protocol TCP -Action Allow
```
**MongoDB** :
```powershell
New-NetFirewallRule -DisplayName "MongoDB Server" -Direction Inbound -LocalPort 27017 -Protocol TCP -Action Allow
```
### Serveur Email
**SMTP** :
```powershell
New-NetFirewallRule -DisplayName "SMTP" -Direction Inbound -LocalPort 25 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "SMTP Submission" -Direction Inbound -LocalPort 587 -Protocol TCP -Action Allow
```
**IMAP** :
```powershell
New-NetFirewallRule -DisplayName "IMAP" -Direction Inbound -LocalPort 143 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "IMAPS" -Direction Inbound -LocalPort 993 -Protocol TCP -Action Allow
```
**POP3** :
```powershell
New-NetFirewallRule -DisplayName "POP3" -Direction Inbound -LocalPort 110 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "POP3S" -Direction Inbound -LocalPort 995 -Protocol TCP -Action Allow
```
## Partie 4 : Gestion des Règles Existantes
### Lister Toutes les Règles
```powershell
Get-NetFirewallRule | Select-Object DisplayName, Direction, Action, Enabled | Format-Table
```
### Lister les Règles pour un Port Spécifique
```powershell
Get-NetFirewallRule | Where-Object {$_.LocalPort -eq 8080}
```
### Rechercher une Règle par Nom
```powershell
Get-NetFirewallRule -DisplayName "Minecraft*"
```
### Activer une Règle Désactivée
```powershell
Enable-NetFirewallRule -DisplayName "Nom de la Règle"
```
### Désactiver une Règle
```powershell
Disable-NetFirewallRule -DisplayName "Nom de la Règle"
```
### Supprimer une Règle
```powershell
Remove-NetFirewallRule -DisplayName "Nom de la Règle"
```
### Modifier une Règle Existante
```powershell
Set-NetFirewallRule -DisplayName "Nom de la Règle" -LocalPort 9090
```
## Partie 5 : Vérification des Ports Ouverts
### Vérifier qu'un Port est Ouvert
#### Via PowerShell (Test de Connexion Locale)
```powershell
Test-NetConnection -ComputerName localhost -Port 8080
```
Si le port est ouvert, vous verrez :
```
TcpTestSucceeded : True
```
#### Via CMD (Netstat)
```cmd
netstat -an | findstr :8080
```
Si le port écoute, vous verrez une ligne comme :
```
TCP 0.0.0.0:8080 0.0.0.0:0 LISTENING
```
### Vérifier depuis l'Extérieur
#### Outils en Ligne
Utilisez ces sites pour tester l'accessibilité de vos ports depuis Internet :
- **CanYouSeeMe** : https://canyouseeme.org/
- **PortChecker** : https://portchecker.co/
- **YouGetSignal** : https://www.yougetsignal.com/tools/open-ports/
1. Entrez votre **IP publique** du VPS
2. Entrez le **numéro de port**
3. Cliquez sur **Check**
#### Via Telnet (depuis un autre PC)
```cmd
telnet VOTRE_IP_VPS 8080
```
Si la connexion réussit, le port est ouvert.
## Partie 6 : Sécurité et Bonnes Pratiques
### Principes de Sécurité
1. **N'ouvrez que les ports nécessaires**
- Chaque port ouvert est un risque potentiel
- Fermez les ports inutilisés
2. **Utilisez des ports non-standard** (optionnel)
- Changez les ports par défaut (ex : SSH sur 2222 au lieu de 22)
- Réduit les attaques automatisées
3. **Limitez l'accès par IP** quand possible
- Restreignez l'accès aux IPs de confiance
- Exemple : RDP uniquement depuis votre IP
4. **Utilisez toujours le chiffrement**
- HTTPS au lieu de HTTP
- SFTP au lieu de FTP
- SSL/TLS pour les bases de données
### Restriction par Adresse IP
Pour autoriser un port uniquement depuis certaines IPs :
```powershell
New-NetFirewallRule -DisplayName "RDP Sécurisé" -Direction Inbound -LocalPort 3389 -Protocol TCP -Action Allow -RemoteAddress 203.0.113.10,198.51.100.20
```
### Limitation du Débit (Rate Limiting)
Windows n'a pas de rate limiting natif dans le pare-feu, mais vous pouvez :
1. Utiliser des outils tiers comme **PeerBlock**
2. Configurer **Windows Defender Advanced Threat Protection**
3. Utiliser un pare-feu matériel ou logiciel tiers
### Journalisation (Logging)
Pour activer la journalisation des connexions :
1. Ouvrez **Pare-feu Windows Defender avec fonctions avancées**
2. Cliquez droit sur **Pare-feu Windows Defender avec fonctions avancées (ordinateur local)**
3. Sélectionnez **Propriétés**
4. Pour chaque profil (Domaine, Privé, Public) :
- Cliquez sur l'onglet
- Section **Journalisation**, cliquez sur **Personnaliser**
- Définissez :
- **Enregistrer les paquets perdus** : Oui
- **Enregistrer les connexions réussies** : Oui
- **Taille maximale** : 4096 Ko (ou plus)
- Notez l'emplacement du fichier journal
5. Consultez les logs dans :
```
C:\Windows\System32\LogFiles\Firewall\pfirewall.log
```
## Partie 7 : Scripts PowerShell Utiles
### Script pour Ouvrir Plusieurs Ports
Créez un fichier `open-ports.ps1` :
```powershell
# Script d'ouverture de ports multiples
# Définir les ports à ouvrir
$ports = @(
@{Name="HTTP"; Port=80; Protocol="TCP"},
@{Name="HTTPS"; Port=443; Protocol="TCP"},
@{Name="FTP"; Port=21; Protocol="TCP"},
@{Name="Minecraft"; Port=25565; Protocol="TCP"},
@{Name="Minecraft"; Port=25565; Protocol="UDP"}
)
# Ouvrir chaque port
foreach ($port in $ports) {
$ruleName = "$($port.Name) - Port $($port.Port) $($port.Protocol)"
Write-Host "Ouverture du port $($port.Port) ($($port.Protocol)) pour $($port.Name)..." -ForegroundColor Green
New-NetFirewallRule -DisplayName $ruleName `
-Direction Inbound `
-LocalPort $port.Port `
-Protocol $port.Protocol `
-Action Allow `
-ErrorAction SilentlyContinue
}
Write-Host "Tous les ports ont été ouverts avec succès!" -ForegroundColor Cyan
```
Exécutez-le :
```powershell
.\open-ports.ps1
```
### Script pour Fermer Tous les Ports Non Essentiels
```powershell
# Lister les règles personnalisées
$rules = Get-NetFirewallRule | Where-Object {$_.DisplayName -notlike "Core*" -and $_.DisplayName -notlike "@*"}
# Afficher et désactiver
foreach ($rule in $rules) {
Write-Host "Désactivation de : $($rule.DisplayName)" -ForegroundColor Yellow
Disable-NetFirewallRule -DisplayName $rule.DisplayName
}
Write-Host "Terminé!" -ForegroundColor Green
```
### Script de Vérification des Ports
```powershell
# Liste des ports à vérifier
$ports = @(80, 443, 3389, 25565)
$hostname = "localhost"
Write-Host "Vérification des ports sur $hostname..." -ForegroundColor Cyan
foreach ($port in $ports) {
$result = Test-NetConnection -ComputerName $hostname -Port $port -WarningAction SilentlyContinue
if ($result.TcpTestSucceeded) {
Write-Host "Port $port : OUVERT" -ForegroundColor Green
} else {
Write-Host "Port $port : FERMÉ" -ForegroundColor Red
}
}
```
## Partie 8 : Dépannage
### Le Port est Ouvert mais Inaccessible
**Vérifications** :
1. **Application ne démarre pas**
- Vérifiez que votre application écoute sur le bon port
- Utilisez `netstat -an | findstr :PORT`
2. **Pare-feu de l'hébergeur**
- Certains hébergeurs ont leur propre pare-feu
- Vérifiez le panel de votre hébergeur VPS
3. **Port déjà utilisé**
```powershell
Get-Process -Id (Get-NetTCPConnection -LocalPort 8080).OwningProcess
```
4. **Écoute sur mauvaise interface**
- Vérifiez que l'application écoute sur `0.0.0.0` et non `127.0.0.1`
### Erreur "Cannot Create Rule"
**Solutions** :
1. Exécutez PowerShell en administrateur
2. Vérifiez qu'une règle avec le même nom n'existe pas :
```powershell
Get-NetFirewallRule -DisplayName "Nom de la Règle"
```
3. Supprimez la règle existante si nécessaire :
```powershell
Remove-NetFirewallRule -DisplayName "Nom de la Règle"
```
### Les Règles ne s'Appliquent Pas
**Solutions** :
1. **Redémarrez le service de pare-feu** :
```powershell
Restart-Service mpssvc
```
2. **Vérifiez que le pare-feu est activé** :
```powershell
Get-NetFirewallProfile | Select-Object Name, Enabled
```
3. **Activez le pare-feu si nécessaire** :
```powershell
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled True
```
### Port Ouvert mais Connexion Lente
**Causes possibles** :
1. **Problème de bande passante**
- Vérifiez l'utilisation réseau du VPS
2. **MTU incorrect**
- Testez différentes tailles de MTU
3. **Latence élevée**
- Utilisez `ping` pour vérifier la latence
## Partie 9 : Configuration Avancée
### Créer des Groupes de Règles
Pour organiser vos règles :
```powershell
# Créer plusieurs règles avec le même groupe
New-NetFirewallRule -DisplayName "Web Server HTTP" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow -Group "Serveurs Web"
New-NetFirewallRule -DisplayName "Web Server HTTPS" -Direction Inbound -LocalPort 443 -Protocol TCP -Action Allow -Group "Serveurs Web"
```
### Activer/Désactiver un Groupe
```powershell
# Désactiver tous les serveurs web
Get-NetFirewallRule -Group "Serveurs Web" | Disable-NetFirewallRule
# Réactiver
Get-NetFirewallRule -Group "Serveurs Web" | Enable-NetFirewallRule
```
### Règles Basées sur le Service
Autoriser un service Windows spécifique :
```powershell
New-NetFirewallRule -DisplayName "Remote Desktop" -Direction Inbound -Service TermService -Action Allow
```
### Blocage par Défaut avec Exceptions
Pour un serveur hautement sécurisé :
1. Bloquez tout le trafic entrant par défaut
2. Autorisez uniquement les services nécessaires
```powershell
# Bloquer tout le trafic entrant
Set-NetFirewallProfile -Profile Public,Private,Domain -DefaultInboundAction Block
# Autoriser uniquement RDP et Web
New-NetFirewallRule -DisplayName "RDP Allowed" -Direction Inbound -LocalPort 3389 -Protocol TCP -Action Allow
New-NetFirewallRule -DisplayName "HTTPS Allowed" -Direction Inbound -LocalPort 443 -Protocol TCP -Action Allow
```
## Partie 10 : Outils Tiers
### Logiciels de Pare-feu Avancés
Pour des fonctionnalités supplémentaires :
1. **GlassWire**
- Interface graphique intuitive
- Monitoring en temps réel
- Alertes de connexion
2. **TinyWall**
- Léger et gratuit
- Interface simplifiée du pare-feu Windows
- Mode apprentissage
3. **ZoneAlarm**
- Protection avancée
- Détection d'intrusion
- Version gratuite disponible
### Outils de Test de Port
1. **Nmap** (depuis un autre PC)
```bash
nmap -p 80,443,8080 VOTRE_IP_VPS
```
2. **PortQry** (Microsoft)
- Téléchargez depuis Microsoft
- Teste les ports localement et à distance
3. **PsPing** (Sysinternals)
- Test avancé de latence et bande passante
```cmd
psping VOTRE_IP_VPS:8080
```
## Commandes de Référence Rapide
### Création de Règles
```powershell
# TCP Entrant
New-NetFirewallRule -DisplayName "Nom" -Direction Inbound -LocalPort PORT -Protocol TCP -Action Allow
# UDP Entrant
New-NetFirewallRule -DisplayName "Nom" -Direction Inbound -LocalPort PORT -Protocol UDP -Action Allow
# TCP Sortant
New-NetFirewallRule -DisplayName "Nom" -Direction Outbound -LocalPort PORT -Protocol TCP -Action Allow
# Plusieurs ports
New-NetFirewallRule -DisplayName "Nom" -Direction Inbound -LocalPort 80,443,8080 -Protocol TCP -Action Allow
# Plage de ports
New-NetFirewallRule -DisplayName "Nom" -Direction Inbound -LocalPort 5000-5100 -Protocol TCP -Action Allow
# IP spécifique
New-NetFirewallRule -DisplayName "Nom" -Direction Inbound -LocalPort PORT -Protocol TCP -Action Allow -RemoteAddress IP
```
### Gestion de Règles
```powershell
# Lister toutes les règles
Get-NetFirewallRule
# Rechercher une règle
Get-NetFirewallRule -DisplayName "Nom*"
# Activer une règle
Enable-NetFirewallRule -DisplayName "Nom"
# Désactiver une règle
Disable-NetFirewallRule -DisplayName "Nom"
# Supprimer une règle
Remove-NetFirewallRule -DisplayName "Nom"
# Modifier une règle
Set-NetFirewallRule -DisplayName "Nom" -LocalPort NOUVEAU_PORT
```
### Vérification
```powershell
# Tester un port localement
Test-NetConnection -ComputerName localhost -Port PORT
# Voir les ports en écoute
netstat -an | findstr LISTENING
# Voir quel processus utilise un port
Get-Process -Id (Get-NetTCPConnection -LocalPort PORT).OwningProcess
```
## Ressources Supplémentaires
### Documentation Microsoft
- **Pare-feu Windows** : https://docs.microsoft.com/fr-fr/windows/security/threat-protection/windows-firewall/
- **NetSecurity PowerShell** : https://docs.microsoft.com/en-us/powershell/module/netsecurity/
- **Sécurité Windows Server** : https://docs.microsoft.com/fr-fr/windows-server/security/
### Communauté et Forums
- **Microsoft Tech Community** : https://techcommunity.microsoft.com/
- **Stack Overflow** : Tag `windows-firewall`
- **Reddit** : r/sysadmin
## Conclusion
Vous savez maintenant comment ouvrir et gérer les ports sur votre VPS Windows ! Les points essentiels à retenir :
**Configuration de Base** :
- Utilisez le Pare-feu Windows Defender avec fonctions avancées
- Créez des règles de trafic entrant pour chaque port
- Nommez clairement vos règles pour une gestion facile
**Sécurité** :
- N'ouvrez que les ports strictement nécessaires
- Limitez l'accès par IP quand possible
- Activez la journalisation pour surveiller les connexions
- Utilisez des protocoles chiffrés (HTTPS, SFTP, etc.)
**Maintenance** :
- Vérifiez régulièrement les ports ouverts
- Supprimez les règles obsolètes
- Testez l'accessibilité de vos services
- Surveillez les logs du pare-feu
**Bonne configuration de votre VPS Windows !**