Je recherche une solution en ligne de commande qui me renverrait l'adresse IP principale (première) de l'hôte local, autre que 127.0.0.1

La solution devrait fonctionner au moins pour Linux (Debian et RedHat) et OS X 10.7+

Je suis conscient qu'il ifconfigest disponible sur les deux mais sa sortie n'est pas aussi cohérente entre ces plates-formes.

Utilisez greppour filtrer l'adresse 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'

Ou avec sed:

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

Si vous n'êtes intéressé que par certaines interfaces, wlan0, eth0, etc.:

ifconfig wlan0 | ...

Vous pouvez alias la commande dans votre .bashrcpour créer votre propre commande appelée myippar exemple.

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

Une manière beaucoup plus simple est hostname -I( hostname -ipour les anciennes versions de hostnamemais voir les commentaires). Cependant, c'est uniquement sous Linux.

Les éléments suivants fonctionneront sous Linux mais pas OSX.

Cela ne repose pas du tout sur DNS, et cela fonctionne même s'il /etc/hostsn'est pas défini correctement ( 1est un raccourci pour 1.0.0.0):

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

ou en évitant awket en utilisant le DNS public de Google à des 8.8.8.8fins d'évidence:

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

Un moyen moins fiable: (voir commentaire ci-dessous)

hostname -I | cut -d' ' -f1

Pour les machines Linux (pas OS X):

hostname --ip-address

sous Linux

hostname -I

sur macOS

ipconfig getifaddr en0

hostname -Ipeut renvoyer plusieurs adresses dans un ordre peu fiable (voir la hostnamepage de manuel ), mais pour moi, il revient simplement 192.168.1.X, ce que vous vouliez.

Solution

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

Explication

La façon correcte d'interroger les informations réseau consiste à utiliser ip:

• -o sortie sur une ligne
• route get to obtenir la route réelle du noyau vers une destination
• 8.8.8.8 Google IP, mais peut utiliser la véritable IP que vous souhaitez atteindre

par exemple ipsortie:

8.8.8.8 via 192.168.8.254 dev enp0s25 src 192.168.8.16 uid 1000 \   cache

Pour extraire l' srcip, sedc'est le plus léger et le plus compatible avec le support regex:

• -n pas de sortie par défaut
• 's/pattern/replacement/p' faire correspondre le motif et le remplacement d'impression uniquement
• .*src \([0-9.]\+\).* correspondre à l'IP src utilisée par le noyau, pour atteindre 8.8.8.8

par exemple sortie finale:

192.168.8.16

Autres réponses

Je pense qu'aucune des réponses précédentes n'est assez bonne pour moi, car elles ne fonctionnent pas sur une machine récente (Gentoo 2018).

Problèmes rencontrés avec les réponses précédentes:

• utilisation de la colonne positionnelle dans la sortie de commande;
• dont l'utilisation ifconfigest déconseillée et - par exemple - ne répertorie pas plusieurs adresses IP;
• utilisation awkpour une tâche simple que sed peut mieux gérer;
• ip route get 1 n'est pas clair, et est en fait un alias pour ip route get to 1.0.0.0
• utilisation de la hostnamecommande, qui n'a pas d' -Ioption dans tous les appareils et qui revient 127.0.0.1dans mon cas.

Modifié ( 2014-06-01 2018-01-09)

Pour une configuration plus solide, avec de nombreuses interfaces et de nombreuses IP configurées sur chaque interface, j'ai écrit un script bash pur (non basé sur 127.0.0.1) pour trouver une interface et une IP correctes , basées sur default route. Je poste ce script tout en bas de cette réponse.

Intro

Comme les deux Os l'ont frapper installé par défaut, il existe une astuce bash pour Mac et Linux:

Le problème des paramètres régionaux est évité par l'utilisation 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

Mettre cela dans une fonction:

Minimal:

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

Utilisation simple:

getMyIP
192.168.1.37

Rangement de fantaisie:

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
}

Usage:

getMyIP
192.168.1.37

ou, en exécutant la même fonction, mais avec un argument:

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

Nota: Sans argument, cette fonction sort sur STDOUT, l'IP et une nouvelle ligne , avec un argument, rien n'est imprimé, mais une variable nommée comme argument est créée et contient IP sans nouvelle ligne .

Nota2: Cela a été testé sur Debian, LaCie hacked nas et MaxOs. Si cela ne fonctionne pas dans votre environnement, je serai très intéressé par les retours!

Ancienne version de cette réponse

(Non supprimé car basé sur sed, non bash.)

Avertir: il y a un problème avec les locales!

Rapide et petit:

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

Explosé (travail aussi;)

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

Éditer:

Comment! Cela ne semble pas fonctionner sur Mac OS ...

Ok, cela semble fonctionner de la même manière sur Mac OS que sur mon 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; }')

divisé:

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;
        }')

Mon script (janvier 2018):

Ce script trouvera d'abord votre route et votre interface par défaut utilisées, puis recherchera le réseau local correspondant à l'IP de la passerelle et remplira les variables. Les deux dernières lignes s'impriment, quelque chose comme:

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

ou

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

Et bien voilà:

#!/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

Spécifique à certaines versions d'Ubuntu uniquement. Bien que cela puisse simplement vous dire 127.0.0.1:

hostname  -i

ou

hostname -I

Vous pouvez également obtenir l'adresse IP version 4 de eth0 en utilisant cette commande sous linux

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

La sortie sera comme ceci

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

Cela fonctionne sur Linux et OSX

Cela obtiendra l'interface associée à la route par défaut

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;}'`

En utilisant l'interface découverte ci-dessus, obtenez l'adresse 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

Darwin laptop 14.4.0 Darwin Kernel Version 14.4.0: Thu May 28 11:35:04 PDT 2015; racine: 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 Thu Sep 3 04:03:03 EDT 2009 x86_64 x86_64 x86_64 GNU / Linux

echo $NET_IF

eth0

echo $NET_IP

192.168.46.10

Utilisation de certaines des autres méthodes Vous pouvez entrer en conflit où plusieurs adresses IP sont définies sur le système. Cette ligne obtient toujours l'adresse IP utilisée par défaut.

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

Im extraire mon commentaire à cette réponse:

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

Il se base sur la réponse @CollinAnderson qui n'a pas fonctionné dans mon cas.

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

Le moyen le plus court pour obtenir votre adresse IPv4 locale sur votre système Linux:

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

En supposant que vous ayez besoin de votre adresse IP publique principale telle qu'elle apparaît dans le reste du monde, essayez l'une d'entre elles:

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

Je dois ajouter à la réponse de Collin Andersons que cette méthode prend également en compte si vous avez deux interfaces et qu'elles apparaissent toutes les deux.

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

J'ai travaillé sur une application avec Raspberry Pi et j'avais besoin de l'adresse IP qui était réellement utilisée, pas seulement si elle était active ou non. La plupart des autres réponses renverront les deux adresses IP, ce qui n'est pas nécessairement utile - pour mon scénario de toute façon.

IP d'interface réseau principale

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

Recherche une adresse IP de cet ordinateur dans un réseau qui est une passerelle par défaut (par exemple exclut tous les réseaux virtuels, les ponts de docker) par exemple. passerelle internet, passerelle wifi, ethernet

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

Fonctionne sous Linux.

Tester:

➜  ~ 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|/.*||'

Une autre ifconfigvariante qui fonctionne à la fois sur Linux et OSX:

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

J'ai parcouru de nombreux liens (StackExchange, AskUbuntu, StackOverflow, etc.) et j'ai décidé de combiner toutes les meilleures solutions en un seul script shell.

À mon avis, ces deux QA sont les meilleurs qu'on puisse voir:

Comment puis-je obtenir mon adresse IP externe dans un script shell? https://unix.stackexchange.com/q/22615

Comment trouver mon adresse IP interne? https://askubuntu.com/a/604691

Voici ma solution basée sur quelques idées de rsp partagées dans son référentiel ( https://github.com/rsp/scripts/ ).

Certains d'entre vous pourraient dire que ce script est extrêmement énorme pour une tâche aussi simple, mais j'aimerais le rendre aussi simple et flexible que possible. Il prend en charge un fichier de configuration simple permettant de redéfinir les valeurs par défaut.

Il a été testé avec succès sous Cygwin, MINGW et Linux (Red Hat).

Afficher l'adresse IP interne

myip -i

Afficher l'adresse IP externe

myip -e

Code source, également disponible par le lien: https://github.com/ildar-shaimordanov/tea-set/blob/master/home/bin/myip . Un exemple de fichier de configuration est là, à côté du 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

J'utilise simplement des noms d'interface réseau , ma commande personnalisée est

[[ $(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' 

dans mon propre cahier

[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 ~]$

mais si l'interface réseau possède au moins une ip, alors elle montrera que toutes les ip lui appartiennent

par exemple

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 ~]#

Il semble que cette commande ip route get 1 | awk '{print $NF;exit}'fournie par le lien soit plus précise, de plus, elle est plus courte.

Vous ne savez pas si cela fonctionne dans tous les systèmes d'exploitation, essayez-le.

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

Il y a un package de nœuds pour tout. Il est multiplateforme et facile à utiliser.

$ npm install --global internal-ip-cli

$ internal-ip
fe80::1

$ internal-ip --ipv4
192.168.0.3

C'est une approche controversée, mais l'utilisation de npm pour l'outillage devient de plus en plus populaire, que cela plaise ou non.

Si vous connaissez l'interface réseau (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]*' 

Fonctionne sur Mac, Linux et à l'intérieur des conteneurs Docker:

$ 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 '{print1 $; sortie}')

Fonctionne également en Makefiletant que:

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}')}

Pour linux, vous avez besoin de cette commande:

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

tapez ceci dans votre shell et vous connaîtrez simplement votre ip.

C'est plus facile à lire: ifconfig | grep 'inet addr:' |/usr/bin/awk '{print $2}' | tr -d addr:

Si vous avez npmet nodeinstallé:npm install -g ip && node -e "const ip = require('ip'); console.log(ip.address())"