Estoy buscando una solución de línea de comando que me devuelva la dirección IP principal (primera) del localhost, que no sea 127.0.0.1

La solución debería funcionar al menos para Linux (Debian y RedHat) y OS X 10.7+

Soy consciente de que ifconfigestá disponible en ambos, pero su salida no es tan consistente entre estas plataformas.

Use greppara filtrar la dirección IP de ifconfig:

ifconfig | grep -Eo 'inet (addr:)?([0-9]*\.){3}[0-9]*' | grep -Eo '([0-9]*\.){3}[0-9]*' | grep -v '127.0.0.1'

O con sed:

ifconfig | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\2/p'

Si solo está interesado en ciertas interfaces, wlan0, eth0, etc., entonces:

ifconfig wlan0 | ...

Puede alias el comando en su .bashrcpara crear su propio comando llamado, myippor ejemplo.

alias myip="ifconfig | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\2/p'"

Una forma mucho más simple es hostname -I( hostname -ipara versiones anteriores de hostnamepero ver comentarios). Sin embargo, esto es solo en Linux.

Lo siguiente funcionará en Linux pero no en OSX.

Esto no depende del DNS en absoluto, y funciona incluso si /etc/hostsno está configurado correctamente ( 1es la abreviatura de 1.0.0.0):

ip route get 1 | awk '{print $NF;exit}'

o evitando awky usando el DNS público de Google en 8.8.8.8obvio:

ip route get 8.8.8.8 | head -1 | cut -d' ' -f8

Una forma menos confiable: (ver comentario más abajo)

hostname -I | cut -d' ' -f1

Para máquinas Linux (no OS X):

hostname --ip-address

en Linux

hostname -I

en macOS

ipconfig getifaddr en0

hostname -Ipuede devolver varias direcciones en un orden poco confiable (vea la página de hostnamemanual ), pero para mí solo regresa 192.168.1.X, que es lo que quería.

Solución

$ ip -o route get to 8.8.8.8 | sed -n 's/.*src \([0-9.]\+\).*/\1/p'
192.168.8.16

Explicación

La forma correcta de consultar la información de la red es usar ip:

• -o salida de una línea
• route get to obtener la ruta real del kernel a un destino
• 8.8.8.8 IP de Google, pero puede usar la IP real que desea alcanzar

por ejemplo, ipsalida:

8.8.8.8 via 192.168.8.254 dev enp0s25 src 192.168.8.16 uid 1000 \   cache

Para extraer el srcip, sedes el más ligero y más compatible con el soporte de expresiones regulares:

• -n sin salida por defecto
• 's/pattern/replacement/p' solo coinciden con el patrón y el reemplazo de impresión
• .*src \([0-9.]\+\).* coincidir con la IP src utilizada por el núcleo, para alcanzar 8.8.8.8

Por ejemplo, salida final:

192.168.8.16

Otras respuestas

Creo que ninguna de las respuestas anteriores es lo suficientemente buena para mí, ya que no funcionan en una máquina reciente (Gentoo 2018).

Problemas que encontré con las respuestas anteriores:

• uso de columna posicional en la salida del comando;
• el uso de los ifconfigcuales está en desuso y, por ejemplo, no enumera las direcciones IP múltiples;
• uso de awkpara una tarea simple que sed puede manejar mejor;
• ip route get 1 no está claro, y en realidad es un alias para ip route get to 1.0.0.0
• uso del hostnamecomando, que no tiene -Iopción en todos los dispositivos y que regresan 127.0.0.1en mi caso.

Editado ( 2014-06-01 2018-01-09)

Para una configuración más fuerte, con muchas interfaces y muchas IP configuradas en cada interfaz, escribí un script bash puro (no basado en 127.0.0.1) para encontrar la interfaz correcta y la IP, basada en default route. Publico este script al final de esta respuesta.

Introducción

Como ambos os tienen golpetazo instalado de forma predeterminada, hay una sugerencia bash para Mac y Linux:

El problema de la configuración regional se evita mediante el uso de LANG=C:

myip=
while IFS=$': \t' read -a line ;do
    [ -z "${line%inet}" ] && ip=${line[${#line[1]}>4?1:2]} &&
        [ "${ip#127.0.0.1}" ] && myip=$ip
  done< <(LANG=C /sbin/ifconfig)
echo $myip

Poniendo esto en una función:

Mínimo:

getMyIP() {
    local _ip _line
    while IFS=$': \t' read -a _line ;do
        [ -z "${_line%inet}" ] &&
           _ip=${_line[${#_line[1]}>4?1:2]} &&
           [ "${_ip#127.0.0.1}" ] && echo $_ip && return 0
      done< <(LANG=C /sbin/ifconfig)
}

Uso simple:

getMyIP
192.168.1.37

Elegante ordenado:

getMyIP() {
    local _ip _myip _line _nl=$'\n'
    while IFS=$': \t' read -a _line ;do
        [ -z "${_line%inet}" ] &&
           _ip=${_line[${#_line[1]}>4?1:2]} &&
           [ "${_ip#127.0.0.1}" ] && _myip=$_ip
      done< <(LANG=C /sbin/ifconfig)
    printf ${1+-v} $1 "%s${_nl:0:$[${#1}>0?0:1]}" $_myip
}

Uso:

getMyIP
192.168.1.37

o, ejecutando la misma función, pero con un argumento:

getMyIP varHostIP
echo $varHostIP
192.168.1.37
set | grep ^varHostIP
varHostIP=192.168.1.37

Nota: Sin argumento, esta función sale en STDOUT, la IP y una nueva línea , con un argumento, no se imprime nada, pero se crea una variable llamada argumento y contiene IP sin nueva línea .

Nota2: Esto fue probado en Debian, LaCie hackeó nas y MaxOs. Si esto no funciona en su entorno, ¡me interesarán mucho los comentarios!

Versión anterior de esta respuesta

(No eliminado porque basado en sed, no bash).

Advertir: ¡Hay un problema con las configuraciones regionales!

Rápido y pequeño:

myIP=$(ip a s|sed -ne '/127.0.0.1/!{s/^[ \t]*inet[ \t]*\([0-9.]\+\)\/.*$/\1/p}')

Explotado (trabajo también;)

myIP=$(
    ip a s |
    sed -ne '
        /127.0.0.1/!{
            s/^[ \t]*inet[ \t]*\([0-9.]\+\)\/.*$/\1/p
        }
    '
)

Editar:

¡Cómo! Esto parece no funcionar en Mac OS ...

Ok, esto parece funcionar bastante igual en Mac OS que en mi Linux :

myIP=$(LANG=C /sbin/ifconfig  | sed -ne $'/127.0.0.1/ ! { s/^[ \t]*inet[ \t]\\{1,99\\}\\(addr:\\)\\{0,1\\}\\([0-9.]*\\)[ \t\/].*$/\\2/p; }')

dividido:

myIP=$(
    LANG=C /sbin/ifconfig  |
        sed -ne $'/127.0.0.1/ ! {
            s/^[ \t]*inet[ \t]\\{1,99\\}\\(addr:\\)\\{0,1\\}\\([0-9.]*\\)[ \t\/].*$/\\2/p;
        }')

Mi guión (enero de 2018):

Esta secuencia de comandos primero encontrará la ruta y la interfaz predeterminadas utilizadas, luego buscará la red local de coincidencia de IP de la puerta de enlace y completará las variables. Las dos últimas líneas simplemente se imprimen, algo así como:

Interface   : en0
Local Ip    : 10.2.5.3
Gateway     : 10.2.4.204
Net mask    : 255.255.252.0
Run on mac  : true

o

Interface   : eth2
Local Ip    : 192.168.1.31
Gateway     : 192.168.1.1
Net mask    : 255.255.255.0
Run on mac  : false

Bueno, ahí está:

#!/bin/bash
runOnMac=false
int2ip() { printf ${2+-v} $2 "%d.%d.%d.%d" \
        $(($1>>24)) $(($1>>16&255)) $(($1>>8&255)) $(($1&255)) ;}
ip2int() { local _a=(${1//./ }) ; printf ${2+-v} $2 "%u" $(( _a<<24 |
                  ${_a[1]} << 16 | ${_a[2]} << 8 | ${_a[3]} )) ;}
while IFS=$' :\t\r\n' read a b c d; do
    [ "$a" = "usage" ] && [ "$b" = "route" ] && runOnMac=true
    if $runOnMac ;then
        case $a in 
            gateway )    gWay=$b  ;;
            interface )  iFace=$b ;;
        esac
    else
        [ "$a" = "0.0.0.0" ] && [ "$c" = "$a" ] && iFace=${d##* } gWay=$b
    fi
done < <(/sbin/route -n 2>&1 || /sbin/route -n get 0.0.0.0/0)
ip2int $gWay gw
while read lhs rhs; do
    [ "$lhs" ] && { 
        [ -z "${lhs#*:}" ] && iface=${lhs%:}
        [ "$lhs" = "inet" ] && [ "$iface" = "$iFace" ] && {
            mask=${rhs#*netmask }
            mask=${mask%% *}
            [ "$mask" ] && [ -z "${mask%0x*}" ] &&
                printf -v mask %u $mask ||
                ip2int $mask mask
            ip2int ${rhs%% *} ip
            (( ( ip & mask ) == ( gw & mask ) )) &&
                int2ip $ip myIp && int2ip $mask netMask
        }
    }
done < <(/sbin/ifconfig)
printf "%-12s: %s\n" Interface $iFace Local\ Ip $myIp \
       Gateway $gWay Net\ mask $netMask Run\ on\ mac $runOnMac

Específico solo para ciertas compilaciones de Ubuntu. Aunque puede que solo te diga 127.0.0.1:

hostname  -i

o

hostname -I

También puede obtener la dirección IP versión 4 de eth0 utilizando este comando en linux

/sbin/ip -4 -o addr show dev eth0| awk '{split($4,a,"/");print a[1]}'

La salida será así

[root@localhost Sathish]# /sbin/ip -4 -o addr show dev eth0| awk '{split($4,a,"/");print a[1]}'
192.168.1.22

Esto funciona en Linux y OSX

Esto obtendrá la interfaz asociada a la ruta predeterminada

NET_IF=`netstat -rn | awk '/^0.0.0.0/ {thif=substr($0,74,10); print thif;} /^default.*UG/ {thif=substr($0,65,10); print thif;}'`

Usando la interfaz descubierta anteriormente, obtenga la dirección IP.

NET_IP=`ifconfig ${NET_IF} | grep -Eo 'inet (addr:)?([0-9]*\.){3}[0-9]*' | grep -Eo '([0-9]*\.){3}[0-9]*' | grep -v '127.0.0.1'`

OSX

uname -a

Laptop Darwin 14.4.0 Darwin Kernel Versión 14.4.0: jue 28 de mayo 11:35:04 PDT 2015; raíz: xnu-2782.30.5 ~ 1 / RELEASE_X86_64 x86_64

echo $NET_IF

en5

echo $NET_IP

192.168.0.130

CentOS Linux

uname -a

Linux dev-cil.medfx.local 2.6.18-164.el5xen 1 SMP jue 3 sep 04:03:03 EDT 2009 x86_64 x86_64 x86_64 GNU / Linux

echo $NET_IF

eth0

echo $NET_IP

192.168.46.10

Uso de algunos de los otros métodos Puede entrar en conflicto donde se definen múltiples direcciones IP en el sistema. Esta línea siempre obtiene la dirección IP por defecto utilizada.

ip route get 8.8.8.8 | head -1 | awk '{print $7}'

Extraigo mi comentario a esta respuesta:

ip route get 1 | sed -n 's/^.*src \([0-9.]*\) .*$/\1/p'

Se basa en la respuesta de @CollinAnderson que no funcionó en mi caso.

ifconfig | grep 'inet ' | grep -v '127.0.0.1' | awk '{print $2}'

La forma más corta de obtener su dirección ipv4 local en su sistema Linux:

hostname -I | awk '{print $1}'

Suponiendo que necesita su IP pública principal como se ve desde el resto del mundo, pruebe cualquiera de los siguientes:

wget http://ipecho.net/plain -O - -q
curl http://icanhazip.com
curl http://ifconfig.me/ip

Tengo que agregar a la respuesta de Collin Anderson que este método también tiene en cuenta si tiene dos interfaces y ambas aparecen como arriba.

ip route get 1 | awk '{print $NF;exit}'

He estado trabajando en una aplicación con Raspberry Pi y necesitaba la dirección IP que realmente se estaba utilizando, no solo si estaba activa o no. La mayoría de las otras respuestas devolverán ambas direcciones IP, lo que no es necesariamente útil, para mi escenario de todos modos.

IP de interfaz de red primaria

ifconfig `ip route | grep default | head -1 | sed 's/\(.*dev \)\([a-z0-9]*\)\(.*\)/\2/g'` | grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b" | head -1

Encuentra una dirección IP de esta computadora en una red que es una puerta de enlace predeterminada (por ejemplo, excluye todas las redes virtuales, puentes acoplables), por ejemplo. puerta de enlace a internet, puerta de enlace wifi, ethernet

ip route| grep $(ip route |grep default | awk '{ print $5 }') | grep -v "default" | awk '/scope/ { print $9 }'

Funciona en Linux.

Prueba:

➜  ~ ip route| grep $(ip route |grep default | awk '{ print $5 }') | grep -v "default" | awk '/scope/ { print $9 }'
192.168.0.114

➜  reverse-networking git:(feature/type-local) ✗ ifconfig wlp2s0
wlp2s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.0.114  netmask 255.255.255.0  broadcast 192.168.0.255
        inet6 fe80::d3b9:8e6e:caee:444  prefixlen 64  scopeid 0x20<link>
        ether ac:x:y:z  txqueuelen 1000  (Ethernet)
        RX packets 25883684  bytes 27620415278 (25.7 GiB)
        RX errors 0  dropped 27  overruns 0  frame 0
        TX packets 7511319  bytes 1077539831 (1.0 GiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

ip addr show | grep -E '^\s*inet' | grep -m1 global | awk '{ print $2 }' | sed 's|/.*||'

Otra ifconfigvariante que funciona tanto en Linux como en OSX:

ifconfig | grep "inet " | cut -f2 -d' '

Revisé muchos enlaces (StackExchange, AskUbuntu, StackOverflow, etc.) y tomé la decisión de combinar las mejores soluciones en un script de shell.

En mi opinión, estos dos QA son los mejores vistos:

¿Cómo puedo obtener mi dirección IP externa en un script de shell? https://unix.stackexchange.com/q/22615

¿Cómo encuentro mi dirección IP interna? https://askubuntu.com/a/604691

Aquí está mi solución basada en algunas ideas de rsp compartidas en su repositorio ( https://github.com/rsp/scripts/ ).

Algunos de ustedes podrían decir que este script es extremadamente grande para una tarea tan simple, pero me gustaría hacerlo lo más fácil y flexible posible en su uso. Admite un archivo de configuración simple que permite redefinir los valores predeterminados.

Fue probado con éxito bajo Cygwin, MINGW y Linux (Red Hat).

Mostrar dirección IP interna

myip -i

Mostrar dirección IP externa

myip -e

Código fuente, también disponible en el enlace: https://github.com/ildar-shaimordanov/tea-set/blob/master/home/bin/myip . El ejemplo del archivo de configuración está allí, junto al script principal.

#!/bin/bash

# =========================================================================
#
# Getting both internal and external IP addresses used for outgoing 
# Internet connections.
#
# Internal IP address is the IP address of your computer network interface 
# that would be used to connect to Internet.
#
# External IP address is the IP address that is visible by external 
# servers that you connect to over Internet.
#
# Copyright (C) 2016 Ildar Shaimordanov
#
# =========================================================================

# Details of the actual implementation are based on the following QA:
#
# How can I get my external IP address in a shell script?
# https://unix.stackexchange.com/q/22615
#
# How do I find my internal ip address?
# https://askubuntu.com/a/604691

# =========================================================================

for f in \
    "$( dirname "$0" )/myip.conf" \
    ~/.myip.conf \
    /etc/myip.conf
do
    [ -f "$f" ] && {
        . "$f"
        break
    }
done

# =========================================================================

show_usage() {
    cat - <<HELP
USAGE
  $( basename "$0" ) [OPTIONS]

DESCRIPTION
  Display the internal and external IP addresses

OPTIONS
  -i  Display the internal IP address
  -e  Display the external IP address
  -v  Turn on verbosity
  -h  Print this help and exit
HELP
    exit
}

die() {
    echo "$( basename "$0" ): $@" >&2
    exit 2
}

# =========================================================================

show_internal=""
show_external=""
show_verbose=""

while getopts ":ievh" opt
do
    case "$opt" in
    i )
        show_internal=1
        ;;
    e )
        show_external=1
        ;;
    v )
        show_verbose=1
        ;;
    h )
        show_usage
        ;;
    \? )
        die "Illegal option: $OPTARG"
        ;;
    esac
done

if [ -z "$show_internal" -a -z "$show_external" ]
then
    show_internal=1
    show_external=1
fi

# =========================================================================

# Use Google's public DNS to resolve the internal IP address
[ -n "$TARGETADDR" ] || TARGETADDR="8.8.8.8"

# Query the specific URL to resolve the external IP address
[ -n "$IPURL" ] || IPURL="ipecho.net/plain"

# Define explicitly $IPCMD to gather $IPURL using another tool
[ -n "$IPCMD" ] || {
    if   which curl >/dev/null 2>&1
    then
        IPCMD="curl -s"
    elif which wget >/dev/null 2>&1
    then
        IPCMD="wget -qO -"
    else
        die "Neither curl nor wget installed"
    fi
}

# =========================================================================

resolveip() {
    {
        gethostip -d "$1" && return
        getent ahostsv4 "$1" \
        | grep RAW \
        | awk '{ print $1; exit }' 
    } 2>/dev/null
}

internalip() {
    [ -n "$show_verbose" ] && printf "Internal: "

    case "$( uname | tr '[:upper:]' '[:lower:]' )" in
    cygwin* | mingw* | msys* )
        netstat -rn \
        | grep -w '0.0.0.0' \
        | awk '{ print $4 }'
        return
        ;;
    esac

    local t="$( resolveip "$TARGETADDR" )"
    [ -n "$t" ] || die "Cannot resolve $TARGETADDR"
    ip route get "$t" \
    | awk '{ print $NF; exit }'
}

externalip() {
    [ -n "$show_verbose" ] && printf "External: "

    eval $IPCMD "$IPURL" $IPOPEN
}

# =========================================================================

[ -n "$show_internal" ] && internalip
[ -n "$show_external" ] && externalip

# =========================================================================

# EOF

Solo utilizo nombres de interfaz de red , mi comando personalizado es

[[ $(ip addr | grep enp0s25) != '' ]] && ip addr show dev enp0s25 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p' || ip addr show dev eth0 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p' 

en mi propio cuaderno

[flying@lempstacker ~]$ cat /etc/redhat-release 
CentOS Linux release 7.2.1511 (Core) 
[flying@lempstacker ~]$ [[ $(ip addr | grep enp0s25) != '' ]] && ip addr show dev enp0s25 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p' || ip addr show dev eth0 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p'
192.168.2.221
[flying@lempstacker ~]$

pero si la interfaz de red posee al menos una ip, mostrará todas las ip que le pertenecen

por ejemplo

Ubuntu 16.10

root@yakkety:~# sed -r -n 's@"@@g;s@^VERSION=(.*)@\1@p' /etc/os-release
16.04.1 LTS (Xenial Xerus)
root@yakkety:~# [[ $(ip addr | grep enp0s25) != '' ]] && ip addr show dev enp0s25 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p' || ip addr show dev eth0 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p'
178.62.236.250
root@yakkety:~#

Debian Jessie

root@jessie:~# sed -r -n 's@"@@g;s@^PRETTY_NAME=(.*)@\1@p' /etc/os-release
Debian GNU/Linux 8 (jessie)
root@jessie:~# [[ $(ip addr | grep enp0s25) != '' ]] && ip addr show dev enp0s25 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p' || ip addr show dev eth0 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p'
192.81.222.54
root@jessie:~# 

CentOS 6.8

[root@centos68 ~]# cat /etc/redhat-release 
CentOS release 6.8 (Final)
[root@centos68 ~]# [[ $(ip addr | grep enp0s25) != '' ]] && ip addr show dev enp0s25 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p' || ip addr show dev eth0 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p'
162.243.17.224
10.13.0.5
[root@centos68 ~]# ip route get 1 | awk '{print $NF;exit}'
162.243.17.224
[root@centos68 ~]#

Fedora 24

[root@fedora24 ~]# cat /etc/redhat-release 
Fedora release 24 (Twenty Four)
[root@fedora24 ~]# [[ $(ip addr | grep enp0s25) != '' ]] && ip addr show dev enp0s25 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p' || ip addr show dev eth0 | sed -n -r 's@.*inet (.*)/.*brd.*@\1@p'
104.131.54.185
10.17.0.5
[root@fedora24 ~]# ip route get 1 | awk '{print $NF;exit}'
104.131.54.185
[root@fedora24 ~]#

Parece que ese comando ip route get 1 | awk '{print $NF;exit}'proporcionado por el enlace es más preciso, lo que es más, es más corto.

No estoy seguro si esto funciona en todos los sistemas operativos, pruébelo.

ifconfig | awk -F"[ :]+" '/inet addr/ && !/127.0/ {print $4}'

Hay un paquete de nodos para todo. Es multiplataforma y fácil de usar.

$ npm install --global internal-ip-cli

$ internal-ip
fe80::1

$ internal-ip --ipv4
192.168.0.3

Este es un enfoque controvertido, pero el uso de npm para herramientas se está volviendo más popular, nos guste o no.

Si conoce la interfaz de red (eth0, wlan, tun0, etc.):

ifconfig eth0 | grep addr: | awk '{ print $2 }' | cut -d: -f2

ifconfig | grep "inet addr:" | grep -v "127.0.0.1" | grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'  | head -1

ifconfig $(netstat -rn | grep -E "^default|^0.0.0.0" | head -1 | awk '{print $NF}') | grep 'inet ' | awk '{print $2}' | grep -Eo '([0-9]*\.){3}[0-9]*' 

Funciona en Mac, Linux y dentro de Docker Containers:

$ hostname --ip-address 2> /dev/null || (ifconfig | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\2/p' | awk '{print$ 1; salida}')

También funciona Makefilecomo:

LOCAL_HOST := ${shell hostname --ip-address 2> /dev/null || (ifconfig | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\2/p' | awk '{print $1; exit}')}

Para Linux, lo que necesita es este comando:

ifconfig $1|sed -n 2p|awk '{ print $2 }'|awk -F : '{ print $2 }'

escriba esto en su shell y simplemente sabrá su ip.

Esto es más fácil de leer: ifconfig | grep 'inet addr:' |/usr/bin/awk '{print $2}' | tr -d addr:

Si tiene npme nodeinstaló:npm install -g ip && node -e "const ip = require('ip'); console.log(ip.address())"