Accueil / Articles / Les proxy

Les proxy

📅 03 janvier 2026
📁 Info
Tutoriel
Les proxy

Introduction : Qu'est-ce qu'un Proxy ?

Un proxy (ou serveur proxy) est un serveur intermédiaire qui agit comme passerelle entre votre appareil et Internet. Lorsque vous utilisez un proxy, vos requêtes passent d'abord par ce serveur avant d'atteindre leur destination finale, puis les réponses reviennent via le même chemin.

Les proxies sont utilisés pour diverses raisons :

  • Anonymat : Masquer votre adresse IP réelle
  • Sécurité : Filtrer le trafic et bloquer les contenus malveillants
  • Contournement : Accéder à des contenus géo-bloqués
  • Performance : Mise en cache pour accélérer l'accès aux sites fréquemment visités
  • Contrôle : Surveiller et filtrer le trafic réseau en entreprise

Dans ce guide, nous allons explorer les différents types de proxies et comment les utiliser efficacement dans vos projets Python et via SSH.

Les Différents Types de Proxies

1. Proxy HTTP/HTTPS

Le proxy HTTP est le type de proxy le plus courant, spécialement conçu pour le trafic web.

Caractéristiques :

  • Fonctionne uniquement avec le protocole HTTP et HTTPS
  • Peut lire et modifier le contenu des requêtes
  • Supporte la mise en cache des pages web
  • Permet l'authentification par nom d'utilisateur/mot de passe
  • Compatible avec tous les navigateurs web

Cas d'usage :

  • Navigation web anonyme
  • Web scraping et automatisation
  • Accès à des sites géo-bloqués
  • Filtrage de contenu en entreprise

Avantages :

  • ✅ Facile à configurer
  • ✅ Largement supporté
  • ✅ Peut mettre en cache le contenu

Inconvénients :

  • ❌ Limité au trafic HTTP/HTTPS
  • ❌ Peut être détecté par les sites web

2. Proxy SOCKS

Le proxy SOCKS (Socket Secure) est un proxy de niveau plus bas, plus flexible que les proxies HTTP.

Caractéristiques :

  • Fonctionne au niveau de la couche session (Layer 5)
  • Peut gérer n'importe quel type de trafic (HTTP, FTP, SMTP, Torrent, etc.)
  • Deux versions principales : SOCKS4 et SOCKS5
  • SOCKS5 supporte l'authentification et UDP
  • Ne modifie pas les paquets

Cas d'usage :

  • Torrents et partage de fichiers
  • Jeux en ligne
  • Applications nécessitant différents protocoles
  • Tunneling SSH

Avantages :

  • ✅ Très flexible (tous types de trafic)
  • ✅ Plus rapide que HTTP pour certains usages
  • ✅ Meilleure compatibilité avec les applications

Inconvénients :

  • ❌ Configuration plus complexe
  • ❌ Pas de mise en cache

3. Proxy Transparent

Le proxy transparent est un proxy qui ne modifie pas les requêtes et ne nécessite pas de configuration côté client.

Caractéristiques :

  • Intercepte automatiquement le trafic sans configuration client
  • L'utilisateur ne sait souvent pas qu'il passe par un proxy
  • Utilisé principalement en entreprise ou par les FAI
  • Peut être détecté facilement

Cas d'usage :

  • Filtrage de contenu en entreprise
  • Mise en cache par les FAI
  • Surveillance du trafic réseau
  • Optimisation de bande passante

Avantages :

  • ✅ Aucune configuration nécessaire
  • ✅ Transparence pour l'utilisateur

Inconvénients :

  • ❌ Pas d'anonymat
  • ❌ Facilement détectable

Utilisation des Proxies en Python

Installation de la bibliothèque requests

La bibliothèque requests est la solution standard pour les requêtes HTTP en Python :

pip install requests

Exemple basique avec proxy HTTP

Voici comment utiliser un proxy HTTP/HTTPS avec Python :

import requests

# Configuration du proxy
proxies = {
    'http': 'http://proxy.example.com:8080',
    'https': 'http://proxy.example.com:8080',
}

# Envoi d'une requête via le proxy
try:
    response = requests.get('http://example.com', proxies=proxies, timeout=10)
    print(f"Status Code: {response.status_code}")
    print(f"Content: {response.text[:200]}...")  # Affiche les 200 premiers caractères
except requests.exceptions.RequestException as e:
    print(f"Erreur: {e}")

Proxy avec authentification

Si votre proxy nécessite une authentification :

import requests

# Proxy avec authentification
proxies = {
    'http': 'http://username:password@proxy.example.com:8080',
    'https': 'http://username:password@proxy.example.com:8080',
}

response = requests.get('https://api.ipify.org?format=json', proxies=proxies)
print(f"Votre IP via le proxy : {response.json()['ip']}")

Utilisation de SOCKS proxy avec Python

Pour utiliser un proxy SOCKS, vous devez installer requests[socks] :

pip install requests[socks]

Puis utilisez-le ainsi :

import requests

# Configuration SOCKS5
proxies = {
    'http': 'socks5://127.0.0.1:1080',
    'https': 'socks5://127.0.0.1:1080',
}

response = requests.get('http://example.com', proxies=proxies)
print(response.text)

Rotation de proxies (pour le web scraping)

Pour éviter les blocages lors du scraping, utilisez plusieurs proxies en rotation :

import requests
import random

# Liste de proxies
proxy_list = [
    'http://proxy1.example.com:8080',
    'http://proxy2.example.com:8080',
    'http://proxy3.example.com:8080',
]

def get_random_proxy():
    """Retourne un proxy aléatoire"""
    return {
        'http': random.choice(proxy_list),
        'https': random.choice(proxy_list),
    }

# Utilisation
for i in range(5):
    proxies = get_random_proxy()
    try:
        response = requests.get('http://example.com', proxies=proxies, timeout=5)
        print(f"Requête {i+1} : Status {response.status_code}")
    except Exception as e:
        print(f"Requête {i+1} échouée: {e}")

Gestion avancée avec une classe Proxy

import requests
from typing import Optional, Dict

class ProxyManager:
    def __init__(self, proxy_url: str, username: Optional[str] = None, password: Optional[str] = None):
        self.proxy_url = proxy_url
        self.username = username
        self.password = password
        
    def get_proxies(self) -> Dict[str, str]:
        """Retourne la configuration du proxy"""
        if self.username and self.password:
            proxy = f"http://{self.username}:{self.password}@{self.proxy_url}"
        else:
            proxy = f"http://{self.proxy_url}"
            
        return {
            'http': proxy,
            'https': proxy,
        }
    
    def make_request(self, url: str, method: str = 'GET', **kwargs):
        """Effectue une requête via le proxy"""
        proxies = self.get_proxies()
        
        try:
            if method.upper() == 'GET':
                response = requests.get(url, proxies=proxies, **kwargs)
            elif method.upper() == 'POST':
                response = requests.post(url, proxies=proxies, **kwargs)
            else:
                raise ValueError(f"Méthode {method} non supportée")
                
            return response
        except requests.exceptions.RequestException as e:
            print(f"Erreur de requête : {e}")
            return None

# Utilisation
proxy_manager = ProxyManager('proxy.example.com:8080', 'user', 'pass')
response = proxy_manager.make_request('http://example.com')

if response:
    print(f"Succès ! Status: {response.status_code}")

Utilisation des Proxies via SSH (Tunneling)

Création d'un tunnel SOCKS avec SSH

SSH permet de créer un proxy SOCKS sécurisé et chiffré. C'est une excellente solution pour protéger votre connexion sur un réseau public.

Commande de base :

ssh -D 8080 -C -N user@remote_host

Explications des options :

  • -D 8080 : Crée un proxy SOCKS dynamique sur le port local 8080
  • -C : Active la compression des données pour améliorer la vitesse
  • -N : N'exécute pas de commande distante (juste le tunnel)
  • -f : (optionnel) Passe en arrière-plan après l'authentification

Configuration avancée du tunnel SSH

Avec clé SSH :

ssh -D 8080 -C -N -i ~/.ssh/id_rsa user@remote_host

Avec keepalive pour éviter les déconnexions :

ssh -D 8080 -C -N -o ServerAliveInterval=60 user@remote_host

En arrière-plan :

ssh -D 8080 -C -N -f user@remote_host

Utilisation du proxy SOCKS créé par SSH

Une fois le tunnel établi, configurez vos applications pour utiliser localhost:8080 comme proxy SOCKS.

Avec Python :

import requests

proxies = {
    'http': 'socks5://127.0.0.1:8080',
    'https': 'socks5://127.0.0.1:8080',
}

response = requests.get('https://api.ipify.org?format=json', proxies=proxies)
print(f"Votre IP via SSH tunnel : {response.json()['ip']}")

Avec curl :

curl --socks5 127.0.0.1:8080 https://api.ipify.org

Configuration navigateur (Firefox) :

  1. Paramètres → Réseau → Paramètres de connexion
  2. Sélectionner "Configuration manuelle du proxy"
  3. Hôte SOCKS : 127.0.0.1
  4. Port : 8080
  5. SOCKS v5

Port Forwarding avec SSH

SSH permet aussi de faire du port forwarding local ou distant :

Local port forwarding :

# Redirige le port local 8080 vers un service distant
ssh -L 8080:localhost:80 user@remote_host

# Accès : http://localhost:8080 → http://remote_host:80

Remote port forwarding :

# Expose un service local sur le serveur distant
ssh -R 9090:localhost:3000 user@remote_host

# Le port 9090 du serveur distant pointe vers localhost:3000

Automatisation avec script

Créez un script pour gérer facilement vos tunnels SSH :

#!/bin/bash
# ssh-tunnel.sh

SSH_USER="user"
SSH_HOST="remote_host"
LOCAL_PORT="8080"

echo "🔒 Création du tunnel SSH SOCKS..."
ssh -D $LOCAL_PORT -C -N -f $SSH_USER@$SSH_HOST

if [ $? -eq 0 ]; then
    echo "✅ Tunnel créé sur localhost:$LOCAL_PORT"
    echo "📝 PID: $(pgrep -f "ssh -D $LOCAL_PORT")"
else
    echo "❌ Erreur lors de la création du tunnel"
    exit 1
fi

Rendez-le exécutable et lancez-le :

chmod +x ssh-tunnel.sh
./ssh-tunnel.sh

Meilleures Pratiques et Sécurité

1. Choisir des proxies fiables

⚠️ Évitez absolument les proxies gratuits publics :

  • ❌ Peuvent voler vos données (mots de passe, cookies)
  • ❌ Injectent souvent des publicités ou malwares
  • ❌ Très lents et peu fiables
  • ❌ Peuvent revendre votre bande passante

✅ Solutions recommandées :

  • VPN professionnel (NordVPN, ProtonVPN, Mullvad)
  • Proxies payants fiables (Bright Data, Oxylabs, SmartProxy)
  • Votre propre serveur (VPS avec SSH tunnel)
  • Proxies d'entreprise (si disponibles)

2. Toujours utiliser HTTPS

Même avec un proxy, utilisez HTTPS pour chiffrer vos communications :

# ✅ BON
response = requests.get('https://example.com', proxies=proxies)

# ❌ MAUVAIS (données en clair)
response = requests.get('http://example.com', proxies=proxies)

3. Gérer les erreurs correctement

import requests
from requests.exceptions import ProxyError, Timeout, RequestException

def safe_request(url, proxies, max_retries=3):
    """Effectue une requête avec gestion d'erreurs"""
    for attempt in range(max_retries):
        try:
            response = requests.get(url, proxies=proxies, timeout=10)
            response.raise_for_status()
            return response
        except ProxyError:
            print(f"❌ Erreur proxy (tentative {attempt + 1}/{max_retries})")
        except Timeout:
            print(f"⏱️ Timeout (tentative {attempt + 1}/{max_retries})")
        except RequestException as e:
            print(f"❌ Erreur : {e}")
            
    return None

4. Respecter les limites de taux

Lors du web scraping avec proxies, respectez les sites web :

import time
import requests

def scrape_with_delay(urls, proxies, delay=2):
    """Scrape avec délai entre requêtes"""
    results = []
    
    for url in urls:
        try:
            response = requests.get(url, proxies=proxies, timeout=10)
            results.append(response.text)
            
            # Délai respectueux
            time.sleep(delay)
        except Exception as e:
            print(f"Erreur pour {url}: {e}")
            
    return results

5. Vérifier votre IP et DNS leaks

Vérifiez que votre proxy fonctionne correctement :

import requests

def check_ip(proxies=None):
    """Vérifie l'IP visible"""
    try:
        response = requests.get('https://api.ipify.org?format=json', proxies=proxies)
        return response.json()['ip']
    except Exception as e:
        return f"Erreur: {e}"

# Sans proxy
print(f"IP réelle: {check_ip()}")

# Avec proxy
proxies = {'http': 'socks5://127.0.0.1:8080', 'https': 'socks5://127.0.0.1:8080'}
print(f"IP via proxy: {check_ip(proxies)}")

6. Sécuriser vos tunnels SSH

Configuration SSH recommandée dans ~/.ssh/config :

Host myproxy
    HostName remote_host
    User username
    Port 22
    IdentityFile ~/.ssh/id_rsa
    DynamicForward 8080
    Compression yes
    ServerAliveInterval 60
    ServerAliveCountMax 3

Utilisation simplifiée :

ssh -N myproxy

Cas d'Usage Pratiques

1. Web Scraping avec rotation de proxies

import requests
from itertools import cycle

# Liste de proxies
proxies_list = [
    'http://proxy1.com:8080',
    'http://proxy2.com:8080',
    'http://proxy3.com:8080',
]

# Créer un itérateur cyclique
proxy_pool = cycle(proxies_list)

# Scraper avec rotation
urls = ['http://example.com/page1', 'http://example.com/page2']

for url in urls:
    proxy = next(proxy_pool)
    proxies = {'http': proxy, 'https': proxy}
    
    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        print(f"✅ {url} via {proxy}: {response.status_code}")
    except Exception as e:
        print(f"❌ Erreur avec {proxy}: {e}")

2. Accès à une API géo-restreinte

import requests

def get_content_from_region(url, country_proxy):
    """Accède à du contenu géo-restreint"""
    proxies = {
        'http': country_proxy,
        'https': country_proxy,
    }
    
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    response = requests.get(url, proxies=proxies, headers=headers)
    return response.text

# Exemple : Accéder à du contenu US
us_proxy = 'http://us-proxy.example.com:8080'
content = get_content_from_region('https://api.example.com/us-only', us_proxy)

3. Test de disponibilité multi-régions

import requests
from concurrent.futures import ThreadPoolExecutor

def test_from_location(location_name, proxy_url, test_url):
    """Teste l'accès depuis une région"""
    proxies = {'http': proxy_url, 'https': proxy_url}
    
    try:
        response = requests.get(test_url, proxies=proxies, timeout=10)
        return {
            'location': location_name,
            'status': response.status_code,
            'time': response.elapsed.total_seconds()
        }
    except Exception as e:
        return {
            'location': location_name,
            'status': 'error',
            'error': str(e)
        }

# Proxies de différentes régions
regions = {
    'USA': 'http://us-proxy.com:8080',
    'Europe': 'http://eu-proxy.com:8080',
    'Asia': 'http://asia-proxy.com:8080',
}

test_url = 'https://your-website.com'

# Test concurrent
with ThreadPoolExecutor(max_workers=3) as executor:
    futures = [
        executor.submit(test_from_location, name, proxy, test_url)
        for name, proxy in regions.items()
    ]
    
    results = [f.result() for f in futures]

for result in results:
    print(f"{result['location']}: {result}")

Conclusion

Les proxies sont des outils puissants pour améliorer la sécurité, l'anonymat et la flexibilité de vos connexions réseau. Que ce soit pour du développement, du web scraping, ou simplement pour protéger votre vie privée, comprendre leur fonctionnement est essentiel.

Points clés à retenir :

  • ✅ HTTP proxies pour le trafic web simple
  • ✅ SOCKS proxies pour plus de flexibilité
  • ✅ SSH tunnels pour la sécurité maximale
  • ✅ Toujours utiliser des proxies fiables et sécurisés
  • ✅ Respecter les bonnes pratiques et l'éthique

En Python, la bibliothèque requests rend l'utilisation des proxies extrêmement simple, tandis que SSH offre une solution gratuite et sécurisée pour créer vos propres tunnels chiffrés.

N'oubliez pas : Utilisez toujours les proxies de manière éthique et légale. Respectez les conditions d'utilisation des sites web que vous visitez et les lois en vigueur dans votre pays.

Article rédigé par Matteo - Développeur et expert en sécurité réseau. Retrouvez plus de tutoriels sur mat-univer.tech.

Dernière mise à jour : Février 2026