Comment obtenir l'adresse IP de l'utilisateur dans Django?

Comment obtenir l'IP de l'utilisateur dans Django?

J'ai une vue comme celle-ci:

# Create your views
from django.contrib.gis.utils import GeoIP
from django.template import  RequestContext
from django.shortcuts import render_to_response


def home(request):
  g = GeoIP()
  client_ip = request.META['REMOTE_ADDR']
  lat,long = g.lat_lon(client_ip)
  return render_to_response('home_page_tmp.html',locals())

Mais je reçois cette erreur:

KeyError at /mypage/
    'REMOTE_ADDR'
    Request Method: GET
    Request URL:    http://mywebsite.com/mypage/
    Django Version: 1.2.4
    Exception Type: KeyError
    Exception Value:    
    'REMOTE_ADDR'
    Exception Location: /mysite/homepage/views.py in home, line 9
    Python Executable:  /usr/bin/python
    Python Version: 2.6.6
    Python Path:    ['/mysite', '/usr/local/lib/python2.6/dist-packages/flup-1.0.2-py2.6.egg', '/usr/lib/python2.6', '/usr/lib/python2.6/plat-linux2', '/usr/lib/python2.6/lib-tk', '/usr/lib/python2.6/lib-old', '/usr/lib/python2.6/lib-dynload', '/usr/local/lib/python2.6/dist-packages', '/usr/lib/python2.6/dist-packages', '/usr/lib/pymodules/python2.6']
    Server time:    Sun, 2 Jan 2011 20:42:50 -0600

def get_client_ip(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    return ip

Assurez-vous que le proxy inverse (le cas échéant) est correctement configuré (par exemple, mod_rpafinstallé pour Apache).

Remarque: ce qui précède utilise le premier élément dans X-Forwarded-For, mais vous voudrez peut-être utiliser le dernier élément (par exemple, dans le cas de Heroku: obtenir la véritable adresse IP du client sur Heroku )

Et puis passez-lui la requête comme argument;

get_client_ip(request)

Vous pouvez utiliser django-ipware qui prend en charge Python 2 et 3 et gère IPv4 et IPv6 .

Installer:

pip install django-ipware

Utilisation simple:

# In a view or a middleware where the `request` object is available

from ipware import get_client_ip
ip, is_routable = get_client_ip(request)
if ip is None:
    # Unable to get the client's IP address
else:
    # We got the client's IP address
    if is_routable:
        # The client's IP address is publicly routable on the Internet
    else:
        # The client's IP address is private

# Order of precedence is (Public, Private, Loopback, None)

Utilisation avancée:

• En-tête personnalisé - En-tête de demande personnalisé pour ipware à regarder:

  i, r = get_client_ip(request, request_header_order=['X_FORWARDED_FOR'])
  i, r = get_client_ip(request, request_header_order=['X_FORWARDED_FOR', 'REMOTE_ADDR'])

• Nombre de proxy - Le serveur Django est derrière un nombre fixe de proxys:

  i, r = get_client_ip(request, proxy_count=1)

• Trusted Proxies - Le serveur Django est derrière un ou plusieurs proxy connus et approuvés:

  i, r = get_client_ip(request, proxy_trusted_ips=('177.2.2.2'))
  
  # For multiple proxies, simply add them to the list
  i, r = get_client_ip(request, proxy_trusted_ips=('177.2.2.2', '177.3.3.3'))
  
  # For proxies with fixed sub-domain and dynamic IP addresses, use partial pattern
  i, r = get_client_ip(request, proxy_trusted_ips=('177.2.', '177.3.'))

Remarque: lisez cet avis .

La réponse d'Alexandre est excellente, mais il lui manque la gestion des proxys qui renvoient parfois plusieurs IP dans l'en-tête HTTP_X_FORWARDED_FOR.

La véritable IP est généralement à la fin de la liste, comme expliqué ici: http://en.wikipedia.org/wiki/X-Forwarded-For

La solution est une simple modification du code d'Alexandre:

def get_client_ip(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[-1].strip()
    else:
        ip = request.META.get('REMOTE_ADDR')
    return ip

Je voudrais suggérer une amélioration de la réponse de Yanchenko.

Au lieu de prendre la première IP de la liste X_FORWARDED_FOR, je prends la première qui, dans une IP interne non connue, car certains routeurs ne respectent pas le protocole, et vous pouvez voir les IPS internes comme la première valeur de la liste.

PRIVATE_IPS_PREFIX = ('10.', '172.', '192.', )

def get_client_ip(request):
    """get the client ip from the request
    """
    remote_address = request.META.get('REMOTE_ADDR')
    # set the default value of the ip to be the REMOTE_ADDR if available
    # else None
    ip = remote_address
    # try to get the first non-proxy ip (not a private ip) from the
    # HTTP_X_FORWARDED_FOR
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        proxies = x_forwarded_for.split(',')
        # remove the private ips from the beginning
        while (len(proxies) > 0 and
                proxies[0].startswith(PRIVATE_IPS_PREFIX)):
            proxies.pop(0)
        # take the first ip which is not a private one (of a proxy)
        if len(proxies) > 0:
            ip = proxies[0]

    return ip

J'espère que cela aide les autres Googleurs qui ont le même problème.

voici une courte ligne pour y parvenir:

request.META.get('HTTP_X_FORWARDED_FOR', request.META.get('REMOTE_ADDR', '')).split(',')[0].strip()

La solution la plus simple (au cas où vous utilisez fastcgi + nignx) est ce qu'itgorilla a commenté:

Merci pour cette excellente question. Mon fastcgi ne transmettait pas la méta-clé REMOTE_ADDR. J'ai ajouté la ligne ci-dessous dans le nginx.conf et corrigé le problème: fastcgi_param REMOTE_ADDR $ remote_addr; - itgorilla

Ps: J'ai ajouté cette réponse juste pour rendre sa solution plus visible.

No More confusion Dans les versions récentes de Django, il est clairement mentionné que l'adresse IP du client est disponible à l'adresse

request.META.get("REMOTE_ADDR")

pour plus d'informations, consultez les documents Django

Dans mon cas, rien de ce qui précède ne fonctionne, donc je dois vérifier uwsgi+ djangole code source et passer un paramètre statique dans nginx et voir pourquoi / comment, et ci-dessous ce que j'ai trouvé.

Info env:
version python : version 2.7.5
Django: (1, 6, 6, 'final', 0)
version nginx: nginx/1.6.0
uwsgi:2.0.7

Env setting info:
nginx en tant que proxy inverse écoutant au port 80 uwsgi en tant que socket unix en amont, répondra éventuellement à la demande

Informations de configuration de Django:

USE_X_FORWARDED_HOST = True # with or without this line does not matter

configuration nginx:

uwsgi_param      X-Real-IP              $remote_addr;
// uwsgi_param   X-Forwarded-For        $proxy_add_x_forwarded_for;
// uwsgi_param   HTTP_X_FORWARDED_FOR   $proxy_add_x_forwarded_for;

// hardcode for testing
uwsgi_param      X-Forwarded-For        "10.10.10.10";
uwsgi_param      HTTP_X_FORWARDED_FOR   "20.20.20.20";

obtenir tous les paramètres dans l'application django:

X-Forwarded-For :       10.10.10.10
HTTP_X_FORWARDED_FOR :  20.20.20.20

Conclusion:

Donc, fondamentalement, vous devez spécifier exactement le même nom de champ / paramètre dans nginx, et utiliser request.META[field/param] dans l'application django.

Et maintenant, vous pouvez décider d'ajouter un middleware (intercepteur) ou simplement d'analyser HTTP_X_FORWARDED_FORcertaines vues.

La raison pour laquelle la fonctionnalité a été supprimée de Django à l'origine était que l'en-tête ne pouvait pas être approuvé en fin de compte. La raison en est qu'il est facile d'usurper. Par exemple, la façon recommandée de configurer un proxy inverse nginx est de:

add_header X-Forwarded-For $proxy_add_x_forwarded_for;
add_header X-Real-Ip       $remote_addr;

Quand vous faites:

curl -H 'X-Forwarded-For: 8.8.8.8, 192.168.1.2' http://192.168.1.3/

Votre nginx sur myhost.com enverra à partir de maintenant:

X-Forwarded-For: 8.8.8.8, 192.168.1.2, 192.168.1.3

le X-Real-IP sera l'IP du premier proxy précédent si vous suivez les instructions à l'aveugle.

Dans le cas où la confiance en vos utilisateurs est un problème, vous pouvez essayer quelque chose comme django-xff: https://pypi.python.org/pypi/django-xff/

Il me manquait également un proxy dans la réponse ci-dessus. J'ai utilisé get_ip_address_from_requestde django_easy_timezones .

from easy_timezones.utils import get_ip_address_from_request, is_valid_ip, is_local_ip
ip = get_ip_address_from_request(request)
try:
    if is_valid_ip(ip):
        geoip_record = IpRange.objects.by_ip(ip)
except IpRange.DoesNotExist:
    return None

Et voici la méthode get_ip_address_from_request, IPv4 et IPv6 prêt:

def get_ip_address_from_request(request):
    """ Makes the best attempt to get the client's real IP or return the loopback """
    PRIVATE_IPS_PREFIX = ('10.', '172.', '192.', '127.')
    ip_address = ''
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR', '')
    if x_forwarded_for and ',' not in x_forwarded_for:
        if not x_forwarded_for.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(x_forwarded_for):
            ip_address = x_forwarded_for.strip()
    else:
        ips = [ip.strip() for ip in x_forwarded_for.split(',')]
        for ip in ips:
            if ip.startswith(PRIVATE_IPS_PREFIX):
                continue
            elif not is_valid_ip(ip):
                continue
            else:
                ip_address = ip
                break
    if not ip_address:
        x_real_ip = request.META.get('HTTP_X_REAL_IP', '')
        if x_real_ip:
            if not x_real_ip.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(x_real_ip):
                ip_address = x_real_ip.strip()
    if not ip_address:
        remote_addr = request.META.get('REMOTE_ADDR', '')
        if remote_addr:
            if not remote_addr.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(remote_addr):
                ip_address = remote_addr.strip()
    if not ip_address:
        ip_address = '127.0.0.1'
    return ip_address

Dans django.VERSION (2, 1, 1, 'final', 0) gestionnaire de demande

sock=request._stream.stream.raw._sock
#<socket.socket fd=1236, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('192.168.1.111', 8000), raddr=('192.168.1.111', 64725)>
client_ip,port=sock.getpeername()

si vous appelez le code ci-dessus deux fois,

AttributeError ("'_ io.BytesIO' objet n'a pas d'attribut 'stream'",)

AttributeError ("L'objet 'LimitedStream' n'a pas d'attribut 'raw'"))