python - español - ¿Cómo obtengo la dirección IP del usuario en django?
django wikipedia (10)
Aquí hay un breve trazador de líneas para lograr esto:
request.META.get(''HTTP_X_FORWARDED_FOR'', request.META.get(''REMOTE_ADDR'')).split('','')[-1].strip()
¿Cómo obtengo la IP del usuario en django?
Tengo una vista como esta:
# 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())
Pero me sale este error:
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
En mi caso, ninguno de los anteriores funciona, así que tengo que verificar el código fuente de uwsgi + django y pasar el parámetro estático en nginx y ver por qué / cómo, y a continuación es lo que he encontrado.
Env información:
Versión de Python: 2.7.5
Versión de Django: (1, 6, 6, ''final'', 0)
Versión nginx: nginx/1.6.0
uwsgi: 2.0.7
Información de configuración de env:
nginx como proxy inverso que escucha en el puerto 80 uwsgi como socket unix en sentido ascendente, responderá eventualmente
Información de configuración de Django:
USE_X_FORWARDED_HOST = True # with or without this line does not matter
config 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";
obteniendo todos los params en la aplicación django:
X-Forwarded-For : 10.10.10.10
HTTP_X_FORWARDED_FOR : 20.20.20.20
Conclusión:
Básicamente, debe especificar exactamente el mismo nombre de campo / param en nginx, y usar request.META[field/param] en la aplicación django.
Y ahora puede decidir si agregar un middleware (interceptor) o simplemente analizar HTTP_X_FORWARDED_FOR en ciertas vistas.
La razón por la que la funcionalidad se eliminó de Django originalmente era que el encabezado no era confiable. La razón es que es fácil de falsificar. Por ejemplo, la forma recomendada de configurar un proxy inverso nginx es:
add_header X-Forwarded-For $proxy_add_x_forwarded_for;
add_header X-Real-Ip $remote_addr;
Cuando tu lo hagas:
curl -H ''X-Forwarded-For: 8.8.8.8, 192.168.1.2'' http://192.168.1.3/
Su nginx en myhost.com enviará en adelante:
X-Forwarded-For: 8.8.8.8, 192.168.1.2, 192.168.1.3
El X-Real-IP será la IP del primer proxy anterior si sigue ciegamente las instrucciones.
En caso de que confiar en quiénes son sus usuarios es un problema, podría intentar algo como django-xff : https://pypi.python.org/pypi/django-xff/
La respuesta de Alexander es excelente, pero carece del manejo de proxies que a veces devuelven múltiples IP en el encabezado HTTP_X_FORWARDED_FOR.
La IP real suele estar al final de la lista, como se explica aquí: http://en.wikipedia.org/wiki/X-Forwarded-For
La solución es una simple modificación del código de Alexander:
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
La solución más fácil para esto es:
from ipaddress import ip_address
y luego usarlo como:
print(get_client_ip(request))
La solución más sencilla (en caso de que estés usando fastcgi + nignx) es lo que comentó itgorilla:
Gracias por esta gran pregunta. Mi fastcgi no estaba pasando la meta clave REMOTE_ADDR. Agregué la siguiente línea en el archivo nginx.conf y solucioné el problema: fastcgi_param REMOTE_ADDR $ remote_addr; - itgorilla
Ps: He añadido esta respuesta solo para hacer su solución más visible.
Me gustaría sugerir una mejora a la respuesta de Yanchenko.
En lugar de tomar la primera ip en la lista X_FORWARDED_FOR, tomo la primera que no es una ip interna conocida, ya que algunos enrutadores no respetan el protocolo, y puedes ver ips internos como el primer valor de la lista.
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
Espero que esto ayude a los colegas de Google que tienen el mismo problema.
Puede usar django-ipware que admite Python 2 y 3 y maneja IPv4 e IPv6 .
Instalar:
pip instalar django-ipware
Uso simple:
Para obtener la dirección IP del cliente.
# 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)
Uso avanzado:
Encabezado personalizado - Encabezado de solicitud personalizado para que ipware vea
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''])
Proxy Count: el servidor Django está detrás de un número fijo de proxies
i, r = get_client_ip(request, proxy_count=1)
Proxies de confianza: el servidor Django está detrás de uno o más proxies conocidos y confiables
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.''))
Nota: lea este notice .
También me faltaba proxy en la respuesta anterior. get_ip_address_from_request de 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
Y aquí está el método get_ip_address_from_request , IPv4 e IPv6 listos:
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
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
Asegúrese de tener el proxy inverso (si lo hay) configurado correctamente (por ejemplo, mod_rpaf instalado para Apache).
Nota: lo anterior utiliza el primer elemento en X-Forwarded-For , pero es posible que desee utilizar el último elemento (por ejemplo, en el caso de Heroku: obtener la dirección IP real del cliente en Heroku )
Y luego simplemente pasa la petición como argumento a ella;
get_client_ip(request)