Quelle commande de terminal pour obtenir uniquement l'adresse IP et rien d'autre?

J'essaie d'utiliser uniquement l'adresse IP (inet) comme paramètre dans un script que j'ai écrit.

Existe-t-il un moyen simple dans un terminal Unix d'obtenir uniquement l'adresse IP, plutôt que de regarder à travers ifconfig?

Vous pouvez écrire un script qui ne renvoie que l'adresse IP comme:

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

Pour Mac:

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

Ou pour le système Linux

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

hostname -i # Debian

Cela vous donnera toutes les interfaces IPv4, y compris le bouclage 127.0.0.1:

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

Cela ne montrera que eth0:

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

Et de cette façon, vous pouvez obtenir des adresses IPv6:

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

Uniquement eth0IPv6:

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

En général, il n'est jamais garanti qu'un système n'aura qu'une seule adresse IP, par exemple, vous pouvez avoir à la fois une connexion Ethernet et WLAN, et si vous avez une connexion VPN active, vous aurez une autre adresse IP.

Linux

Sous Linux, hostname -Ilistera la ou les adresses IP actuelles. S'appuyer dessus en retournant toujours une seule adresse IP ne fonctionnera probablement pas comme prévu dans certains scénarios (c'est-à-dire qu'une liaison VPN est active), donc un moyen plus fiable serait de convertir le résultat en un tableau, puis de boucler sur les éléments:

ips=($(hostname -I))

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

OSX

Sous OSX, si vous connaissez l'interface , vous pouvez utiliser:

~$ ipconfig getifaddr en0
192.168.1.123

qui renverra juste l'adresse IP.

Ou vous pouvez faire une boucle sur les noms d'interface possibles, en commençant par un suffixe, c'est en-à- dire :

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

echo $myip

En outre, l'obtention de l'adresse IP devient non déterministe dans le cas où des connexions par câble et wifi sont établies, lorsqu'une machine a plus d'une interface Ethernet ou lorsque des tunnels VPN sont présents.

Obtention de l'adresse IP externe

Si vous avez besoin de l'adresse IP externe, vous pouvez interroger un service en mode texte, par exemple curl https://ipecho.net/plainrenvoyer une adresse IP externe en texte brut .

Et un moyen encore plus rapide d'obtenir l'adresse IP externe consiste à interroger un serveur DNS connu:

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

hostname -I  

Cette commande vous donnera l'adresse IP exacte que vous voulez dans Ubuntu.

Sur les dernières versions d' Ubuntu ( 14.04 - 16.04 ), cette commande a fait l'affaire pour moi.

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

Si votre environnement est limité, vous pouvez utiliser cette commande:

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

Pour obtenir uniquement l'adresse IP sous Mac OS X, vous pouvez taper la commande suivante:

ipconfig getifaddr en0

La commande ifconfigest obsolète et vous devez utiliser la ipcommande sous Linux.

Vous ip adonnera également une portée sur la même ligne que IP, ce qui facilite son utilisation.

Cette commande vous montrera votre IP globale (externe):

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

Tous IPv4 (également 127.0.0.1):

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

Tout IPv6 (aussi :: 1):

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

Nous pouvons simplement utiliser seulement 2 commandes (ifconfig + awk) pour obtenir juste l'IP (v4) que nous voulons comme ceci:

Sous Linux, en supposant obtenir l'adresse IP de l' eth0interface, exécutez la commande suivante:

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

Sous OSX, en supposant d'obtenir l'adresse IP de l' en0interface, exécutez la commande suivante:

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

Pour connaître notre IP publique / externe, ajoutez cette fonction dans ~/.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"
}

Puis cours, whatismyip

Pour imprimer uniquement l'adresse IP de eth0, sans autre texte:

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

Pour déterminer votre interface principale (car elle n'est peut-être pas "eth0"), utilisez:

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

Les deux lignes ci-dessus peuvent être combinées en une seule commande comme celle-ci:

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

Je voulais quelque chose de simple qui fonctionnait comme un alias Bash. J'ai trouvé que cela hostname -Ifonctionnait le mieux pour moi (hostname v3.15). hostname -irenvoie l'adresse IP de bouclage, pour une raison quelconque, mais hostname -Ime donne l'adresse IP correcte pour wlan0, et sans avoir à diriger la sortie via grep ou awk. Un inconvénient est que toutes les adresses IP hostname -Iseront affichées, si vous en avez plusieurs.

Cela ferait l'affaire dans un Mac:

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

Cela a résolu ping 192.168.1.2dans ma machine.

Astuce de pro : $(...)signifie exécuter tout ce qui se trouve à l'intérieur des parenthèses dans un sous-shell et le renvoyer comme valeur.

Il man hostnameexiste un moyen encore plus simple d'exclure automatiquement les adresses IP de bouclage et d'afficher uniquement la liste séparée par des espaces de toutes les adresses IP attribuées aux hôtes:

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

Vous pouvez également utiliser la commande suivante:

ip route | grep src

REMARQUE: cela ne fonctionnera que si vous êtes connecté à Internet.

Peu de réponses semblent utiliser la nouvelle ipcommande (pour remplacer ifconfig) voici donc celui qui utilise ip addr, grepet awkpour imprimer simplement l'adresse IPv4 associée à l' wlan0interface:

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

Bien que ce ne soit pas la solution la plus compacte ou la plus sophistiquée, elle est (sans doute) facile à comprendre (voir l'explication ci-dessous) et à modifier à d'autres fins, telles que l'obtention des 3 derniers octets de l'adresse MAC comme ceci:

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

Explication: ip addr show wlan0 renvoie des informations associées à l'interface réseau nommée wlan0, qui doivent être similaires à ceci:

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

Suivant les grep inetfiltres sur les lignes qui ne contiennent pas « iNet » (IPv4 et IPv6 configuration) et les grep -v inet6filtres sur les lignes restantes qui font contenir « inet6 », ce qui devrait se traduire par une seule ligne comme celui - ci:

    inet 172.18.18.1/24 brd 172.18.18.255 scope global noprefixroute wlan0

Enfin, le premier awkextrait le champ "172.18.18.1/24" et le second supprime le raccourci du masque de réseau, ne laissant que l'adresse IPv4.

De plus, je pense qu'il vaut la peine de mentionner que si vous créez des scripts, il existe souvent de nombreux outils plus riches et / ou plus robustes pour obtenir ces informations, que vous voudrez peut-être utiliser à la place. Par exemple, si vous utilisez Node.js, il y en a ipaddr-linux, si vous utilisez Ruby linux-ip-parser, etc.

Voir aussi /unix/119269/how-to-get-ip-address-using-shell-script

Utilisez la commande suivante:

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

Voici ma version, dans laquelle vous pouvez passer une liste d'interfaces, classées par priorité:

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 $@

Donc, si je suis connecté avec VPN, Wifi et Ethernet, mon adresse VPN (sur l'interface tap0) sera retournée. Le script fonctionne à la fois sous Linux et osx, et peut prendre des arguments si vous souhaitez remplacer IFLIST

Notez que si vous souhaitez utiliser IPV6, vous devrez remplacer «inet» par «inet6».

Je finis toujours par avoir besoin de cela aux moments les plus inattendus et, sans faute, je finis par chercher des fils comme celui-ci sur SO. J'ai donc écrit un script simple pour obtenir les adresses IPv4 via netstat, appelé echoip- vous pouvez le trouver ici . Le bash pour les adresses réseau ressemble à ceci, il obtient également votre adresse publique 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

Le echoipscript produit une sortie comme celle-ci:

$ echoip
public: 26.106.59.169
en0:    10.1.10.2

utilisez ce script en une ligne: 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 et linux (testé sous ubuntu) fonctionnent tous les deux.

Je préfère ne pas utiliser awket tel dans les scripts .. ipa la possibilité de sortir en JSON.

Si vous omettez, $interfacevous obtenez toutes les adresses 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}'

montre toutes vos ips

Sur Redhat 64bit, ce problème a résolu pour moi.

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

Lorsque vous recherchez votre adresse IP externe sur un hôte NAT, de nombreuses réponses suggèrent d'utiliser des méthodes basées sur HTTP comme ifconfig.mepar exemple:

$ curl ifconfig.me/ip

Au fil des années, j'ai vu beaucoup de ces sites aller et venir, je trouve cette méthode basée sur le DNS plus robuste:

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

J'ai cet alias pratique dans mon ~/.bashrc:

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

Ces deux méthodes ont fonctionné pour moi:

Pour obtenir l'adresse IP de votre interface eth0. Remplacez eth0 dans l'exemple ci-dessous par le nom de votre interface. ifconfig eth0 | grep -w "inet" | tr -s " " | cut -f3 -d" "

Utilisation du nom d'hôte: Cela vous donnera l'inet ie IPAddress de votre etho. en utilisant -I vous donnera la valeur inet de toutes les interfaces où que cette valeur soit présente.

hostname -i

curl ifconfig.co 

Cela renvoie uniquement l'adresse IP de votre système.

J'utiliserais Hostname -Lpour obtenir uniquement l'adresse IP à utiliser comme variable dans un script.