¿Qué comando de terminal obtener solo la dirección IP y nada más?

Estoy tratando de usar solo la dirección IP (inet) como parámetro en un script que escribí.

¿Existe una manera fácil en un terminal Unix de obtener solo la dirección IP, en lugar de mirar a través ifconfig?

Puede escribir un script que solo devuelva la IP como:

/sbin/ifconfig eth0 | grep 'inet addr' | cut -d: -f2 | awk '{print $1}'

Para Mac:

ifconfig | grep "inet " | grep -v 127.0.0.1 | cut -d\  -f2

O para el sistema linux

hostname -i | awk '{print $3}' # Ubuntu 

hostname -i # Debian

Esto le dará todas las interfaces IPv4, incluido el loopback 127.0.0.1:

ip -4 addr | grep -oP '(?<=inet\s)\d+(\.\d+){3}'

Esto solo mostrará eth0:

ip -4 addr show eth0 | grep -oP '(?<=inet\s)\d+(\.\d+){3}'

Y de esta manera puede obtener direcciones IPv6:

ip -6 addr | grep -oP '(?<=inet6\s)[\da-f:]+'

Solo eth0IPv6:

ip -6 addr show eth0 | grep -oP '(?<=inet6\s)[\da-f:]+'

En general, nunca se garantiza que un sistema solo tendrá una dirección IP, por ejemplo, puede tener conexiones Ethernet y WLAN, y si tiene una conexión VPN activa, tendrá otra dirección IP.

Linux

En Linux, hostname -Imostrará la (s) dirección (es) IP actuales. Confiar en que siempre devuelva solo una dirección IP probablemente no funcionará como se espera en algunos escenarios (es decir, un enlace VPN está activo), por lo que una forma más confiable sería convertir el resultado en una matriz y luego recorrer los elementos:

ips=($(hostname -I))

for ip in "${ips[@]}"
do
    echo $ip
done

OSX

En OSX, si conoce la interfaz , puede usar:

~$ ipconfig getifaddr en0
192.168.1.123

que devolverá solo la dirección IP.

O puede recorrer los posibles nombres de interfaz, comenzando con un sufijo, es decir en:

for NUMBER in $(seq 0 5); do
    ip=`ipconfig getifaddr en$NUMBER`
    if [ -n "$ip" ]; then
        myip="$ip"
        break
    fi
done

echo $myip

Además, la obtención de la dirección IP se vuelve no determinista en caso de que se establezcan conexiones por cable y wifi, cuando una máquina tiene más de una interfaz Ethernet o cuando hay túneles VPN presentes.

Obtener la IP externa

Si necesita la IP externa, puede consultar un servicio en modo texto, por ejemplo curl https://ipecho.net/plain, devolvería una IP externa de texto sin formato .

Y una forma aún más rápida de obtener la IP externa es consultar un servidor DNS conocido:

dig @ns1-1.akamaitech.net ANY whoami.akamai.net +short

hostname -I  

Este comando le dará la dirección IP exacta que desee en Ubuntu.

En las últimas versiones de Ubuntu ( 14.04 - 16.04 ), este comando funcionó para mí.

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

Si tiene un entorno limitado, puede usar este comando:

ip -4 addr show dev eth0 | grep inet | tr -s " " | cut -d" " -f3 | head -n 1

Para obtener solo la dirección IP en Mac OS X , puede escribir el siguiente comando:

ipconfig getifaddr en0

El comando ifconfigestá obsoleto y debería usar el ipcomando en Linux.

También ip ale dará alcance en la misma línea que IP para que sea más fácil de usar.

Este comando le mostrará su IP global (externa):

ip a | grep "scope global" | grep -Po '(?<=inet )[\d.]+'

Todo IPv4 (también 127.0.0.1):

ip a | grep "scope" | grep -Po '(?<=inet )[\d.]+'

Todo IPv6 (también :: 1):

ip a | grep "scope" | grep -Po '(?<=inet6 )[\da-z:]+'

Simplemente podemos usar solo 2 comandos (ifconfig + awk) para obtener solo la IP (v4) que queremos así:

En Linux, suponiendo que obtenga la dirección IP de la eth0interfaz, ejecute el siguiente comando:

/sbin/ifconfig eth0 | awk '/inet addr/{print substr($2,6)}'

En OSX, suponiendo obtener la dirección IP de la en0interfaz, ejecute el siguiente comando:

/sbin/ifconfig en0 | awk '/inet /{print $2}'

Para conocer nuestra IP pública / externa, agregue esta función en ~/.bashrc

whatismyip () {
    curl -s "http://api.duckduckgo.com/?q=ip&format=json" | jq '.Answer' | grep --color=auto -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b"
}

Entonces corre, whatismyip

Para imprimir solo la dirección IP de eth0, sin otro texto:

ifconfig eth0 | grep -Po '(?<=inet )[\d.]+'

Para determinar su interfaz principal (porque puede que no sea "eth0"), use:

route | grep ^default | sed "s/.* //"

Las dos líneas anteriores se pueden combinar en un solo comando como este:

ifconfig `route | grep ^default | sed "s/.* //"` \
  | grep -Po '(?<=inet )[\d.]+'

Quería algo simple que funcionara como un alias de Bash. Descubrí que hostname -Ifunciona mejor para mí (nombre de host v3.15). hostname -idevuelve la IP de loopback, por alguna razón, pero hostname -Ime da la IP correcta para wlan0, y sin tener que canalizar la salida a través de grep o awk. Un inconveniente es que hostname -Igenerará todas las direcciones IP, si tiene más de una.

Eso haría el truco en una Mac:

ping $(ifconfig en0 | awk '$1 == "inet" {print $2}')

Eso se resolvió ping 192.168.1.2en mi máquina.

Consejo profesional : $(...)significa ejecutar lo que esté dentro de los paréntesis en una subcapa y devolverlo como valor.

En man hostnamehay aún más fácil de forma que automáticamente excluido de bucle invertido IP y mostrando sólo el espacio lista de todos ellos adscritos a las direcciones IP de host separados:

root@srv:~# hostname --all-ip-addresses
11.12.13.14 192.168.15.19 

root@srv:~# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue state UNKNOWN
   link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
   inet 127.0.0.1/8 scope host lo
   inet6 ::1/128 scope host 
   valid_lft forever preferred_lft forever
2: venet0: <BROADCAST,POINTOPOINT,NOARP,UP,LOWER_UP> mtu 1500 qdisc noqueue state UNKNOWN 
  link/void 
  inet 11.12.13.14/32 scope global venet0:0
  inet 192.168.15.19/32 scope global venet0:1

También puede utilizar el siguiente comando:

ip route | grep src

NOTA: Esto solo funcionará si tiene conectividad a Internet.

Algunas respuestas parecen estar utilizando el nuevo ipcomando (reemplazo para ifconfig) así que aquí es uno que utiliza ip addr, grepy awkpara imprimir simplemente la dirección IPv4 asociada a la wlan0interfaz:

ip addr show wlan0|grep inet|grep -v inet6|awk '{print $2}'|awk '{split($0,a,"/"); print a[1]}'

Si bien no es la solución más compacta o elegante, es (posiblemente) fácil de entender (ver la explicación a continuación) y modificar para otros fines, como obtener los últimos 3 octetos de la dirección MAC de esta manera:

ip addr show wlan0|grep link/ether|awk '{print $2}'|awk '{split($0,mac,":"); print mac[4] mac[5] mac[6]}'

Explicación: ip addr show wlan0 genera información asociada con la interfaz de red nombrada wlan0, que debería ser similar a esta:

4: wlan0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether dc:a6:32:04:06:ab brd ff:ff:ff:ff:ff:ff
    inet 172.18.18.1/24 brd 172.18.18.255 scope global noprefixroute wlan0
       valid_lft forever preferred_lft forever
    inet6 fe80::d340:5e4b:78e0:90f/64 scope link 
       valid_lft forever preferred_lft forever

Siguiente grep inetfiltra las líneas que no contienen "inet" (IPv4 y IPv6 configuración) y grep -v inet6filtra las líneas restantes que hacen contener "inet6", lo que debería resultar en una sola línea como la siguiente:

    inet 172.18.18.1/24 brd 172.18.18.255 scope global noprefixroute wlan0

Finalmente, el primero awkextrae el campo "172.18.18.1/24" y el segundo elimina la taquigrafía de la máscara de red, dejando solo la dirección IPv4.

Además, creo que vale la pena mencionar que si está escribiendo un script, a menudo hay muchas herramientas más ricas y / o más sólidas para obtener esta información, que quizás desee utilizar en su lugar. Por ejemplo, si usa Node.js ipaddr-linux, si usa Ruby linux-ip-parser, etc.

Consulte también /unix/119269/how-to-get-ip-address-using-shell-script

Utilice el siguiente comando:

/sbin/ifconfig $(netstat -nr | tail -1 | awk '{print $NF}') | awk -F: '/inet /{print $2}' | cut -f1 -d ' '

Aquí está mi versión, en la que puede pasar una lista de interfaces, ordenadas por prioridad:

getIpFromInterface()
{
    interface=$1
    ifconfig ${interface}  > /dev/null 2>&1 && ifconfig ${interface} | awk -F'inet ' '{ print $2 }' | awk '{ print $1 }' | grep .
}

getCurrentIpAddress(){
    IFLIST=(${@:-${IFLIST[@]}})
    for currentInterface in ${IFLIST[@]}
    do
        IP=$(getIpFromInterface  $currentInterface)
        [[ -z "$IP" ]] && continue
    echo ${IP/*:}
    return
    done
}

IFLIST=(tap0 en1 en0)
getCurrentIpAddress $@

Entonces, si estoy conectado con VPN, Wifi y ethernet, se devolverá mi dirección de VPN (en la interfaz tap0). El script funciona tanto en linux como en osx, y puede aceptar argumentos si desea anular IFLIST

Tenga en cuenta que si desea utilizar IPV6, deberá reemplazar 'inet' por 'inet6'.

Siempre termino necesitando esto en los momentos más inesperados y, sin falta, termino buscando hilos como este en SO. Así que escribí un script simple para obtener direcciones IPv4 a través de netstat, llamado echoip- puedes encontrarlo aquí . El bash para direcciones de red se ve así, también obtiene su dirección pública de ipecho.net:

IPV4='\d+(\.\d+){3}'
INTERFACES=`netstat -i | grep -E "$IPV4" | cut -d ' ' -f 1`
INTERFACE_IPS=`netstat -i | grep -oE "$IPV4"`

for i in "${!INTERFACES[@]}"; do
  printf "%s:\t%s\n" "${INTERFACES[$i]}" "${INTERFACE_IPS[$i]}"
done

El echoipscript produce una salida como esta:

$ echoip
public: 26.106.59.169
en0:    10.1.10.2

use este script de una línea: ifconfig | grep "inet " | grep -v 127.0.0.1|awk 'match($0, /([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/) {print substr($0,RSTART,RLENGTH)}' mac y linux (probado en ubuntu) ambos funcionan.

Prefiero no usar awky tal en scripts .. iptiene la opción de generar en JSON.

Si omite, $interfaceobtendrá todas las direcciones IP:

ip -json addr show $interface | \
  jq -r '.[] | .addr_info[] | select(.family == "inet") | .local'

ip addr|awk '/eth0/ && /inet/ {gsub(/\/[0-9][0-9]/,""); print $2}'

muestra todas tus ips

En Redhat de 64 bits, este problema me resolvió.

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

#!/bin/sh
# Tested on Ubuntu 18.04 and Alpine Linux 
# List IPS of following network interfaces:
# virtual host interfaces
# PCI interfaces
# USB interfaces
# ACPI interfaces
# ETH interfaces
for NETWORK_INTERFACE in $(ls /sys/class/net -al | grep -iE "(/eth[0-9]+$|vif|pci|acpi|usb)" | sed -E "s@.* ([^ ]*) ->.*@\1@"); do 
    IPV4_ADDRESSES=$(ifconfig $NETWORK_INTERFACE | grep -iE '(inet addr[: ]+|inet[: ]+)' | sed -E "s@\s*(inet addr[: ]+|inet[: ]+)([^ ]*) .*@\2@")
    IPV6_ADDRESSES=$(ifconfig $NETWORK_INTERFACE | grep -iE '(inet6 addr[: ]+|inet6[: ]+)' | sed -E "s@\s*(inet6 addr[: ]+|inet6[: ]+)([^ ]*) .*@\2@")
    if [ -n "$IPV4_ADDRESSES" ] || [ -n "$IPV6_ADDRESSES" ]; then
        echo "NETWORK INTERFACE=$NETWORK_INTERFACE"
        for IPV4_ADDRESS in $IPV4_ADDRESSES; do 
            echo "IPV4=$IPV4_ADDRESS"
        done
        for IPV6_ADDRESS in $IPV6_ADDRESSES; do 
            echo "IPV6=$IPV6_ADDRESS"
        done
    fi
done

Al buscar su dirección IP externa en un host con NAT, algunas respuestas sugieren usar métodos basados ​​en HTTP como, ifconfig.mepor ejemplo:

$ curl ifconfig.me/ip

A lo largo de los años, he visto muchos de estos sitios ir y venir, encuentro que este método basado en DNS es más robusto:

$ dig +short myip.opendns.com @resolver1.opendns.com

Tengo este útil alias en mi ~/.bashrc:

alias wip='dig +short myip.opendns.com @resolver1.opendns.com'

Estas dos formas funcionaron para mí:

Para obtener la dirección IP de su interfaz eth0. Reemplace eth0 en el siguiente ejemplo con el nombre de su interfaz. ifconfig eth0 | grep -w "inet" | tr -s " " | cut -f3 -d" "

Usando el nombre de host: Esto le dará el inet, es decir, la dirección IP de su etho. el uso de -I le dará el valor inet de todas las interfaces donde sea que este valor esté presente.

hostname -i

curl ifconfig.co 

Esto devuelve solo la dirección IP de su sistema.

Usaría Hostname -Lpara obtener solo la IP para usar como variable en un script.