Comment faire la géolocalisation d’adresses IP ? Que ce soit pour des raisons de sécurité, de marketing ciblé ou simplement par curiosité, connaître l’origine géographique d’une connexion internet peut s’avérer extrêmement utile. Python, avec sa simplicité et sa puissance, offre plusieurs méthodes efficaces pour localiser des adresses IP.

Comprendre la géolocalisation IP

La géolocalisation IP consiste à déterminer l’emplacement physique associé à une adresse IP spécifique. Cette technologie permet d’identifier le pays, la région, la ville et parfois même les coordonnées géographiques précises d’où provient une connexion internet.

Informations obtenues par géolocalisation

Une géolocalisation IP complète peut fournir les informations suivantes :

• Pays et code pays
• Région/État/Province
• Ville
• Code postal
• Latitude et longitude
• Fuseau horaire
• FAI (Fournisseur d’Accès Internet)
• Organisation

Configuration de l’environnement Python

Avant de commencer à coder, il est nécessaire de préparer votre environnement de développement.

Prérequis

• Python installé sur votre système (version 3.6 ou supérieure recommandée)
• Gestionnaire de paquets pip
• Connexion internet active

Installation des bibliothèques essentielles

Plusieurs bibliothèques Python peuvent être utilisées pour la géolocalisation IP. Voici les principales :

pip install requests
pip install ipinfo
pip install geoip2
pip install ip2geotools
pip install geopy

Méthodes de localisation d’adresses IP avec Python

Utilisation de la bibliothèque Requests avec des API

La bibliothèque Requests est l’une des plus populaires pour effectuer des requêtes HTTP en Python. Elle peut être combinée avec diverses API de géolocalisation IP pour obtenir les informations souhaitées.

Exemple avec l’API ipapi

import requests

def localiser_ip(ip):
    url = f"https://ipapi.co/{ip}/json/"
    response = requests.get(url)
    data = response.json()
    return data

adresse_ip = "8.8.8.8"  # Exemple d'adresse IP (Google DNS)
info_localisation = localiser_ip(adresse_ip)
print(f"Pays : {info_localisation.get('country_name')}")
print(f"Ville : {info_localisation.get('city')}")
print(f"Région : {info_localisation.get('region')}")
print(f"Coordonnées : {info_localisation.get('latitude')}, {info_localisation.get('longitude')}")

Cette méthode est simple et ne nécessite pas d’inscription pour un nombre limité de requêtes. L’API ipapi fournit des informations complètes sur la localisation de l’adresse IP.

Exemple avec l’API ipstack

import requests

def localiser_ip(ip_address, api_key):
    url = f"http://api.ipstack.com/{ip_address}?access_key={api_key}"
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        return data
    else:
        return {"error": "Erreur lors de la requête à l'API"}

# Remplacez "votre_cle_api_ici" par votre clé API ipstack
resultat = localiser_ip("8.8.8.8", "votre_cle_api_ici")
print(f"Pays : {resultat.get('country_name')}")
print(f"Ville : {resultat.get('city')}")
print(f"Latitude : {resultat.get('latitude')}")
print(f"Longitude : {resultat.get('longitude')}")

L’API ipstack nécessite une clé d’API, mais offre une précision accrue et des fonctionnalités supplémentaires.

Utilisation de la bibliothèque GeoIP2

GeoIP2 est une bibliothèque puissante qui utilise les bases de données de MaxMind pour la géolocalisation IP. Elle offre une grande précision mais nécessite le téléchargement d’une base de données.

import geoip2.database

def localiser_ip(ip):
    # Chemin vers la base de données GeoLite2 téléchargée
    reader = geoip2.database.Reader('chemin/vers/GeoLite2-City.mmdb')
    response = reader.city(ip)
    reader.close()
    return response

adresse_ip = "8.8.8.8"  # Exemple d'adresse IP
info_localisation = localiser_ip(adresse_ip)
print(f"Pays : {info_localisation.country.name}")
print(f"Ville : {info_localisation.city.name}")
print(f"Coordonnées : {info_localisation.location.latitude}, {info_localisation.location.longitude}")

Pour utiliser GeoIP2, vous devez :

1. Créer un compte sur le site de MaxMind
2. Télécharger la base de données GeoLite2 City
3. Spécifier le chemin vers cette base de données dans votre code

Utilisation de ip2geotools

La bibliothèque ip2geotools offre une interface simple pour déterminer la localisation géographique d’une adresse IP.

from ip2geotools.databases.noncommercial import DbIpCity

def printDetails(ip):
    res = DbIpCity.get(ip, api_key="free")
    print(f"IP Address: {res.ip_address}")
    print(f"Location: {res.city}, {res.region}, {res.country}")
    print(f"Coordinates: (Lat: {res.latitude}, Lng: {res.longitude})")

# Exemple d'utilisation
ip_add = "198.35.26.96"  # Exemple d'adresse IP
printDetails(ip_add)

Cette bibliothèque prend en charge les adresses IPv4 et IPv6 et peut gérer des adresses IP individuelles ou des listes d’adresses IP.

Localisation d’un domaine à partir de son URL

Vous pouvez également localiser un domaine en convertissant d’abord son URL en adresse IP :

import socket
from ip2geotools.databases.noncommercial import DbIpCity

def localiser_domaine(url):
    # Supprimer le préfixe http:// ou https:// s'il existe
    if url.startswith("http://"):
        url = url[7:]
    elif url.startswith("https://"):
        url = url[8:]

    # Supprimer le chemin après le domaine
    url = url.split("/")[0]

    try:
        ip_add = socket.gethostbyname(url)
        res = DbIpCity.get(ip_add, api_key="free")
        return {
            "ip": ip_add,
            "ville": res.city,
            "region": res.region,
            "pays": res.country,
            "latitude": res.latitude,
            "longitude": res.longitude
        }
    except Exception as e:
        return {"erreur": str(e)}

# Exemple d'utilisation
info = localiser_domaine("www.youtube.com")
print(info)

Utilisation de l’API IPinfo

IPinfo est un service populaire qui fournit des informations détaillées sur les adresses IP. Python dispose d’une bibliothèque wrapper officielle pour faciliter son utilisation.

import ipinfo

def get_ip_info(ip_address, access_token):
    handler = ipinfo.getHandler(access_token)
    details = handler.getDetails(ip_address)
    return details.all

# Remplacez par votre token d'accès IPinfo
access_token = "votre_token_acces_ici"
ip_address = "8.8.8.8"  # Exemple d'adresse IP
details = get_ip_info(ip_address, access_token)

print(f"IP: {details.get('ip')}")
print(f"Ville: {details.get('city')}")
print(f"Région: {details.get('region')}")
print(f"Pays: {details.get('country')}")
print(f"Localisation: {details.get('loc')}")
print(f"Organisation: {details.get('org')}")
print(f"Code postal: {details.get('postal')}")
print(f"Fuseau horaire: {details.get('timezone')}")

Comparaison des différentes méthodes

Voici un tableau comparatif des différentes méthodes de géolocalisation IP en Python :

Optimisation et bonnes pratiques

Gestion des erreurs

Il est crucial d’implémenter une gestion robuste des erreurs lors de la géolocalisation IP :

import requests

def localiser_ip(ip):
    try:
        url = f"https://ipapi.co/{ip}/json/"
        response = requests.get(url, timeout=5)
        response.raise_for_status()  # Lève une exception si la réponse contient une erreur HTTP
        data = response.json()

        # Vérifier si l'API a retourné une erreur
        if "error" in data:
            return {"erreur": data["error"]}

        return data
    except requests.exceptions.Timeout:
        return {"erreur": "Délai d'attente dépassé"}
    except requests.exceptions.ConnectionError:
        return {"erreur": "Problème de connexion"}
    except requests.exceptions.HTTPError as e:
        return {"erreur": f"Erreur HTTP: {e}"}
    except ValueError:  # Inclut JSONDecodeError
        return {"erreur": "Réponse non valide"}
    except Exception as e:
        return {"erreur": f"Erreur inattendue: {str(e)}"}

Mise en cache des résultats

Pour optimiser les performances et réduire les appels API, implémentez un système de mise en cache :

import requests
import json
import os
import time

# Durée de validité du cache en secondes (1 jour)
CACHE_DURATION = 86400

def localiser_ip_avec_cache(ip):
    cache_dir = "ip_cache"
    cache_file = f"{cache_dir}/{ip}.json"

    # Créer le répertoire de cache s'il n'existe pas
    if not os.path.exists(cache_dir):
        os.makedirs(cache_dir)

    # Vérifier si l'IP est en cache et si le cache est valide
    if os.path.exists(cache_file):
        with open(cache_file, 'r') as f:
            cache_data = json.load(f)

        # Vérifier si le cache est encore valide
        if time.time() - cache_data["timestamp"] < CACHE_DURATION:
            return cache_data["data"]

    # Si pas en cache ou cache expiré, faire la requête
    url = f"https://ipapi.co/{ip}/json/"
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()

        # Sauvegarder dans le cache
        cache_content = {
            "timestamp": time.time(),
            "data": data
        }
        with open(cache_file, 'w') as f:
            json.dump(cache_content, f)

        return data
    else:
        return {"erreur": "Impossible de récupérer les données"}

Respect de la vie privée et considérations éthiques

Lorsque vous utilisez la géolocalisation IP, gardez à l’esprit les considérations éthiques suivantes :

• Consentement : Informez les utilisateurs que vous collectez leur adresse IP et l’utilisez pour la géolocalisation
• Confidentialité : Stockez les données de manière sécurisée et anonymisez-les si possible
• Conformité légale : Respectez les réglementations comme le RGPD en Europe
• Limites d’utilisation : Respectez les limites d’utilisation des API que vous utilisez

Applications pratiques

La géolocalisation IP avec Python peut être utilisée dans de nombreux contextes :

• Sécurité informatique : Détection d’accès suspects depuis des localisations inhabituelles
• Marketing ciblé : Adaptation du contenu en fonction de la localisation de l’utilisateur
• Analyse de trafic : Compréhension de la répartition géographique des visiteurs
• Restriction de contenu : Limitation de l’accès à certains contenus en fonction de la localisation
• Personnalisation : Adaptation de l’expérience utilisateur selon la région (langue, devise, etc.)

Récap

Python offre de nombreuses options pour localiser des adresses IP, allant des solutions simples utilisant des API gratuites aux méthodes plus avancées avec des bases de données locales. Le choix de la méthode dépendra de vos besoins spécifiques en termes de précision, de volume de requêtes et de budget.

En suivant les bonnes pratiques et en implémentant une gestion robuste des erreurs, vous pouvez intégrer efficacement la géolocalisation IP dans vos applications Python. N’oubliez pas de respecter la vie privée des utilisateurs et de vous conformer aux réglementations en vigueur concernant la collecte et l’utilisation des données.