Comment puis-je obtenir ma propre adresse IP et la sauvegarder dans une variable dans un script shell?

Ce n'est pas si facile si vous voulez prendre en compte wlan et d'autres interfaces alternatives. Si vous savez quelle interface vous voulez utiliser pour l'adresse (par exemple, eth0, la première carte Ethernet), vous pouvez utiliser ceci:

ip="$(ifconfig | grep -A 1 'eth0' | tail -1 | cut -d ':' -f 2 | cut -d ' ' -f 1)"

En d'autres termes, obtenez-moi les informations de configuration du réseau, recherchez eth0, obtenez cette ligne et la suivante ( -A 1), obtenez uniquement la dernière ligne, obtenez la deuxième partie de cette ligne lors de la scission avec :, puis la première partie lors de la scission avec de l'espace.

Je crois que la "méthode moderne" pour obtenir votre adresse ipv4 consiste à analyser "ip" plutôt que "ifconfig", ce qui donnerait quelque chose du genre:

ip4=$(/sbin/ip -o -4 addr list eth0 | awk '{print $4}' | cut -d/ -f1)
ip6=$(/sbin/ip -o -6 addr list eth0 | awk '{print $4}' | cut -d/ -f1)

ou quelque chose comme ça.

Pourquoi ne pas simplement faire IP=$(hostname -I)?

Si vous voulez l'adresse d'une interface, le moyen le plus simple est d'installer moreutils alors:

anthony@Zia:~$ ifdata -pa br0
172.16.1.244

ifdatarépond à peu près à chaque question pour laquelle vous seriez tenté d'analyser la ifconfigsortie.

Si vous voulez connaître votre adresse IP comme le voit l'extérieur (au-delà de tout NAT, etc.), de nombreux services vous le permettront. On est assez facile:

anthony@Zia:~$ curl ifconfig.me
173.167.51.137

Pour obtenir les adresses IPv4 et IPv6 sans supposer que l’interface principale est eth0(ces jours-ci em1 est plus courant ), essayez:

ips=$(ip -o addr show up primary scope global |
      while read -r num dev fam addr rest; do echo ${addr%/*}; done)

• -outilise le format de sortie d' une ligne, ce qui est plus facile à traiter avec read, grepetc.
• up exclut les appareils qui ne sont pas actifs
• scope globalexclut les adresses privées / locales telles que 127.0.0.1etfe80::/64
• primaryexclut les adresses temporaires (en supposant que vous souhaitiez une adresse qui ne change pas)

Cela dépend de ce que vous entendez par propre adresse IP. Les systèmes ont des adresses IP sur plusieurs sous-réseaux (parfois plusieurs par sous-réseau), dont certains IPv4, certains IPv6 utilisant des périphériques tels que des adaptateurs Ethernet, des interfaces de bouclage, des tunnels VPN, des ponts, des interfaces virtuelles ...

Lorsque vous parlez de l'adresse IP par laquelle un autre périphérique donné peut atteindre votre ordinateur, vous devez déterminer le sous-réseau concerné et la version d'IP dont nous parlons. De plus, n'oubliez pas qu'en raison de la traduction d'adresses réseau réalisée par le pare-feu / les routeurs, l'adresse IP d'une interface peut être différente de celle qu'un hôte distant voit apparaître une connexion entrante en provenance de votre ordinateur.

Lorsqu'il existe un routage source sophistiqué ou par protocole / port, il peut être difficile de déterminer l'interface utilisée pour communiquer avec un ordinateur distant via un protocole donné. Même dans ce cas, rien ne garantit que l'adresse IP de cette interface puisse être utilisée. directement adressable par l’ordinateur distant souhaitant établir une nouvelle connexion avec votre ordinateur.

Pour IPv4 (fonctionne probablement aussi pour IPv6), une astuce qui fonctionne dans de nombreux systèmes, y compris Linux, pour rechercher l'adresse IP de l'interface utilisée pour atteindre un hôte donné consiste à utiliser un connecteur (2) sur un socket UDP et à utiliser getsockname. ():

Par exemple, sur mon ordinateur à la maison:

perl -MSocket -le 'socket(S, PF_INET, SOCK_DGRAM, getprotobyname("udp"));
connect(S, sockaddr_in(1, inet_aton("8.8.8.8")));
print inet_ntoa((sockaddr_in(getsockname(S)))[1]);'

Serait utilisé pour trouver l'adresse IP de l'interface via laquelle j'atteindrais 8.8.8.8 (serveur DNS de Google). Il renverrait quelque chose comme "192.168.1.123", qui est l'adresse de l'interface pour la route par défaut vers Internet. Cependant, Google ne verrait pas les requêtes DNS de ma machine comme provenant de cette adresse IP, qui est une adresse privée, car le routeur haut débit de ma maison utilise la NAT.

connect () sur un socket UDP n'envoie aucun paquet (UDP n'a pas de connexion), mais prépare le socket en interrogeant la table de routage.

ipa=$(ip route get 8.8.8.8| grep src| sed 's/.*src \(.*\)$/\1/g')

ipa=$(hostname -i|cut -f2 -d ' ')

Je ne veux pas être un imbécile, mais il y a vraiment un bon moyen et c'est tout. Vous coupez la sortie de ip routepour obtenir uniquement l'adresse IP source. Selon l'adresse IP que vous essayez d'atteindre, "ma propre adresse IP" (les mots de l'OP) sera différente. Si vous souhaitez accéder à Internet, utilisez le serveur DNS 8.8.8.8 de Google est assez standard. Alors...

La réponse courte est:

ip route get 8.8.8.8 | sed -n '/src/{s/.*src *\([^ ]*\).*/\1/p;q}'

Voici l'explication détaillée

Si je veux que l'adresse IP que j'utilise atteigne Internet , j'utilise ceci:

pi@et3:~ $ ip route get 8.8.8.8 | sed -n '/src/{s/.*src *\([^ ]*\).*/\1/p;q}'
10.55.0.200

Si je veux que l'adresse IP que j'utilise atteigne quelque chose sur mon VPN , j'utilise ceci:

pi@et3:~ $ ip route get 172.31.0.100 | sed -n '/src/{s/.*src *\([^ ]*\).*/\1/p;q}'
172.29.0.9

Ce prochain est vraiment juste à des fins d'illustration. Mais cela devrait fonctionner sur n’importe quel système Linux. Ainsi, vous pouvez utiliser ceci pour démontrer que, oui, toutes les machines ont plusieurs adresses IP à tout moment.

Si je voulais que l'adresse IP que j'utilise me contacte , j'utiliserais ceci:

pi@et3:~ $ my_ip=$(getent hosts $(cat /etc/hostname) | awk '{print $1; exit}')
pi@et3:~ $ ip route get $my_ip | sed -n '/src/{s/.*src *\([^ ]*\).*/\1/p;q}'
127.0.0.1

En savoir plus sur cette sedcommande

Tout d’abord, laissez-moi vous dire que lorsque vous choisissez des outils Unix, vous essayez de choisir les outils qui nécessitent le moins de pipes. Ainsi, alors que quelques réponses redirigera ifconfigà grepà sedà head, qui est rarement nécessaire. Lorsque vous le voyez, il convient de signaler que vous prenez conseil auprès d'une personne peu expérimentée. Cela ne rend pas la "solution" fausse. Mais, il pourrait probablement utiliser une certaine rationalisation.

J'ai choisi sedparce qu'il est plus concis que le même flux de travail awk. (J'ai depuis un exemple awk ci-dessous.) Je ne pense pas qu'un autre outil, mais ces 2 serait approprié.

Examinons ce que sed -n '/src/{s/.*src *\([^ ]*\).*/\1/p;q}'fait:

sed            # the sed executable located via $PATH
-n             # no output unless explicitly requested
'              # begin the command space
/src/          # regex match the string 'src'
{              # begin a block of commands **
s/             # begin a substitution (match)
  .*src *      # match anything leading up to and including src and any number of spaces
  \([^ ]*\)    # define a group containing any number of non spaces
  .*           # match any trailing characters (which will begin with a space because of the previous rule).
/              # begin the substitution replacement
  \1           # reference the content in the first defined group
/              # end the substitution
p              # print (explicitly, remember) the result
;              # designate the end of the command
q              # quit
}              # end the block of commands
'              # end the command space

** all of which will be performed "on match"
  - otherwise only the first command to following the match would be performed "on match"
    - any other commands would be performed whether there was a match or not

J'avais l'habitude d'utiliser sed -n '/src/{s/.*src *//p;q}'mais un commentateur a souligné que certains systèmes ont des données de fuite après le srcchamp.

Utiliser awk

ip route get 8.8.8.8 | \
    awk '{gsub(".*src",""); print $1; exit}'

# or

ip route get 8.8.8.8 | \
    awk '{for(i=1; i<NF; i++){if($i=="src"){i++; print $i; exit}}}'

Plus sur mon réseau

Mes ifconfigémissions que j'ai tun0pour mon VPN et eth0pour mon réseau local.

pi@et3:~ $ ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 10.55.0.200  netmask 255.255.252.0  broadcast 10.55.3.255
        inet6 fe80::71e6:5d7c:5b4b:fb25  prefixlen 64  scopeid 0x20<link>
        ether b8:27:eb:b2:96:84  txqueuelen 1000  (Ethernet)

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1  (Local Loopback)

tun0: flags=4305<UP,POINTOPOINT,RUNNING,NOARP,MULTICAST>  mtu 1500
        inet 172.29.0.9  netmask 255.255.255.255  destination 172.29.0.10
        inet6 fe80::3a8e:8195:b86c:c68c  prefixlen 64  scopeid 0x20<link>
        unspec 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00  txqueuelen 100  (UNSPEC)

wlan0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        ether b8:27:eb:e7:c3:d1  txqueuelen 1000  (Ethernet)

Sur FreeBSD, vous pouvez utiliser

dig +short `hostname -f`

Cela peut fonctionner pour d'autres environnements, cela dépend de votre configuration.

En supposant que vous puissiez avoir différentes interfaces de nom différent mais que vous voulez le premier non-hôte local et non-ipv6, vous pouvez essayer:

ip=`ip addr show |grep "inet " |grep -v 127.0.0. |head -1|cut -d" " -f6|cut -d/ -f1`

J'utilise ce one-liner:

IP=$(/sbin/ifconfig | grep -e "inet:" -e "addr:" | grep -v "inet6" | grep -v "127.0.0.1" | head -n 1 | awk '{print $2}' | cut -c6-)

Utilisations ifconfig(largement disponibles), ne prend pas d' localhostadresse, ne vous lie pas à un nom d'interface donné, ne prend pas en compte IPv6 et tente d'obtenir l'IP de la première interface réseau disponible.

myip=$(curl -kLs "http://api.ipify.org")

ou

myip=$(wget -q "http://api.ipify.org" -O -)

Vous devriez utiliser ip(au lieu de ifconfig) car il est actuel, maintenu et, peut-être plus important encore, à des fins de script, il produit une sortie cohérente et analysable. Voici quelques approches similaires:

Si vous voulez l'adresse IPv4 pour votre interface Ethernet eth0:

$ ip -4 -o addr show eth0 | awk '{print $4}'
192.168.1.166/24  

En tant que script:

$ INTFC=eth0  
$ MYIPV4=$(ip -4 -o addr show $INTFC | awk '{print $4}') 
$ echo $MYIPV4
192.168.1.166/24

La sortie produite ci-dessus est en notation CIDR. Si la notation CIDR n'est pas souhaitée, elle peut être supprimée:

$ ip -4 -o addr show eth0 | awk '{print $4}' | cut -d "/" -f 1 
192.168.1.166  

Une autre option, à mon humble avis, qui est "la plus élégante", consiste à obtenir l'adresse IPv4 de l'interface utilisée pour se connecter à l'hôte distant spécifié (8.8.8.8 dans ce cas). Gracieuseté de @gatoatigrado dans cette réponse :

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

En tant que script:

$ RHOST=8.8.8.8  
$ MYIP=$(ip route get $RHOST | awk '{ print $NF; exit }')
$ echo $MYIP
192.168.1.166

Cela fonctionne parfaitement sur un hôte avec une seule interface, mais plus avantageusement, il fonctionne également sur des hôtes avec plusieurs interfaces et / ou spécifications de route.

ipCe serait mon approche préférée, mais ce n’est certainement pas le seul moyen de dépouiller ce chat. Voici une autre approche que hostnamevous utilisez si vous préférez quelque chose de plus simple / concis:

$ hostname --all-ip-addresses | awk '{print $1}'  

Ou, si vous voulez l'adresse IPv6:

$ hostname --all-ip-addresses | awk '{print $2}'  

Je devais faire cela dans un alias pour démarrer un serveur de radio sur ma carte réseau câblée. j'ai utilisé

ip addr | egrep -i "inet.+eth1" | awk -F[\ /] '{print $6}' | tr -d [:space:]

Certaines commandes fonctionnent sur les centos 6 ou 7, la commande ci-dessous fonctionne à la fois,

#!/bin/sh

serverip=`/sbin/ifconfig eth0 | grep "inet" | awk '{print $2}' | awk 'NR==1' | cut -d':' -f2`

echo $serverip

En supposant que vous ayez besoin de votre adresse IP publique principale telle qu'elle est vue du reste du monde , essayez l'une de ces solutions:

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

Ce fragment de code évite de coder en dur le nom du périphérique (comme 'eth0') et utilisera à la ipplace de ifconfig:

/sbin/ip addr | grep 'state UP' -A2 | tail -n1 | awk '{print $2}' | cut -f1  -d'/'

Il renverra l'adresse IP du premier périphérique actif répertorié dans la sortie de ip addr. Selon votre machine, il peut s'agir d'une adresse ipv4 ou ipv6.

Pour le stocker dans une variable, utilisez:

ip=$(/sbin/ip addr | grep 'state UP' -A2 | tail -n1 | awk '{print $2}' | cut -f1  -d'/')

toutes les solutions utilisant awk / sed / grep semblent excessivement complexes et laides pour ma situation ... alors j’ai imaginé cette solution très simple MAIS méfiez-vous car elle fait quelques hypothèses, à savoir l’hypothèse que la dernière interface est celle que vous utilisez. intéressé. si ça vous va, alors c'est assez propre:

ifconfig | awk '/net / { x = $2 } END { print x }'

sinon, vous pourriez faire une ifdéclaration idiote pour tester un préfixe spécifique ou un critère quelconque.

Commande simple pour affiner l'adresse IP avec l'interface par défaut.

ip route | grep src | awk '{print $NF; exit}'

Testé sur tous les systèmes d'exploitation Unix

Ce n'est peut-être pas la solution la plus robuste ou la plus correcte, mais contrairement à la plupart des autres solutions, la commande fonctionne à la fois sous Linux et Mac (BSD).

host `hostname` | awk '{print $NF}'

Si vous recherchez une adresse IP publique de la boîte , vous pouvez utiliser les éléments suivants:

• dig @ns1.google.com -t txt o-o.myaddr.l.google.com +short | tr -d \"

Vous pouvez utiliser des dig(1)options telles que -4ou -6pour rechercher spécifiquement une adresse IPv4 ou IPv6; Google fournira une réponse dans un enregistrement de TXTtype, qui sera entouré de guillemets lorsqu’il sera présenté par dig; si vous voulez utiliser ensuite la variable avec des utilitaires tels que traceroute, vous devez utiliser quelque chose comme tr (1) pour supprimer les guillemets.

Les autres options incluent whoami.akamai.netet myip.opendns.com, qui répondent avec Aet des AAAAenregistrements (au lieu de TXTcomme dans l'exemple ci-dessus de Google), elles ne nécessitent donc pas la suppression des guillemets:

• dig -4 @ns1-1.akamaitech.net -t a whoami.akamai.net +short

• dig -4 @resolver1.opendns.com -t any myip.opendns.com +short

• dig -6 @resolver1.opendns.com -t any myip.opendns.com +short

Voici un exemple de script qui utilise toutes les options ci-dessus pour définir les variables:

#!/bin/sh
IPANY="$(dig @ns1.google.com -t txt o-o.myaddr.l.google.com +short | tr -d \")"
GOOGv4="$(dig -4 @ns1.google.com -t txt o-o.myaddr.l.google.com +short | tr -d \")"
GOOGv6="$(dig -6 @ns1.google.com -t txt o-o.myaddr.l.google.com +short | tr -d \")"
AKAMv4="$(dig -4 @ns1-1.akamaitech.net -t a whoami.akamai.net +short)"
CSCOv4="$(dig -4 @resolver1.opendns.com -t a myip.opendns.com +short)"
CSCOv6="$(dig -6 @resolver1.opendns.com -t aaaa myip.opendns.com +short)"
printf '$GOOG:\t%s\t%s\t%s\n' "${IPANY}" "${GOOGv4}" "${GOOGv6}"
printf '$AKAM:\t%s\n$CSCO:\t%s\t%s\n' "${AKAMv4}" "${CSCOv4}" "${CSCOv6}"

Si vous recherchez une adresse IP privée ou un ensemble de toutes les adresses IP attribuées à la boîte, vous pouvez utiliser une combinaison de ifconfig(sur BSD et GNU / Linux), ip addr(sur GNU / Linux), hostname(options -iet -Isur GNU / Linux) et netstatde voir ce qui se passe.

hostname -I >> file_name 

cela fera tout ce que vous voulez