¿Cómo obtengo la dirección IP del usuario en django?

¿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

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_rpafinstalado para Apache).

Nota: lo anterior utiliza el primer elemento X-Forwarded-For, pero es posible que desee utilizar el último elemento (por ejemplo, en el caso de Heroku: Obtenga la dirección IP real del cliente en Heroku )

Y luego simplemente pasa la solicitud como argumento;

get_client_ip(request)

Puede usar django-ipware que admite Python 2 y 3 y maneja IPv4 e IPv6 .

Instalar en pc:

pip install django-ipware

Uso 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)

Uso avanzado:

• Encabezado personalizado: encabezado de solicitud personalizado para que ipware lo 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'])

• Recuento de proxy: el servidor de Django está detrás de un número fijo de servidores proxy:

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

• Proxies de confianza: el servidor de Django está detrás de uno o más proxies conocidos y de confianza:

  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 aviso .

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-Forwards-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

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 puede 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 compañeros de Google que tienen el mismo problema.

Aquí hay un breve resumen para lograr esto:

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

La solución más simple (en caso de que esté usando fastcgi + nignx) es lo que itgorilla comentó:

Gracias por esta gran pregunta Mi fastcgi no estaba pasando la meta clave REMOTE_ADDR. Agregué la siguiente línea en nginx.conf y solucioné el problema: fastcgi_param REMOTE_ADDR $ remote_addr; - itgorilla

Ps: agregué esta respuesta solo para hacer que su solución sea más visible.

No más confusión En las versiones recientes de Django se menciona claramente que la dirección IP del cliente está disponible en

request.META.get("REMOTE_ADDR")

Para obtener más información, consulte los documentos de Django

En mi caso, ninguno de los anteriores funciona, así que tengo que verificar uwsgi+ djangocódigo fuente y pasar el parámetro estático en nginx y ver por qué / cómo, y a continuación es lo que he encontrado.

Información de env:
versión de python : versión de 2.7.5
Django: (1, 6, 6, 'final', 0)
versión de 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 de unix ascendente, eventualmente responderá a la solicitud

Información de configuración de Django:

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

nginx config:

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 campo / nombre de parámetro en nginx y usarlo request.META[field/param]en la aplicación django.

Y ahora puede decidir si agregar un middleware (interceptor) o simplemente analizar HTTP_X_FORWARDED_FORen ciertas vistas.

La razón por la que la funcionalidad se eliminó de Django originalmente fue que el encabezado no es confiable. La razón es que es fácil de engañar. 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

los X-Real-IP será el IP de la primera representación anterior si se siguen las instrucciones ciegamente.

En caso de que confiar en quiénes son sus usuarios sea un problema, puede intentar algo como django-xff: https://pypi.python.org/pypi/django-xff/

También me faltaba proxy en la respuesta anterior. Solía 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

Y aquí está el método get_ip_address_from_request, IPv4 e IPv6 listo:

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

En django.VERSION (2, 1, 1, 'final', 0) manejador de solicitudes

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 llama dos veces al código anterior, puede obtener

AttributeError ("'_ io.BytesIO' el objeto no tiene atributo 'stream'",)

AttributeError ("el objeto 'LimitedStream' no tiene el atributo 'raw'")