Qual comando de terminal para obter apenas o endereço IP e nada mais?

Estou tentando usar apenas o endereço IP (inet) como parâmetro em um script que escrevi.

Existe uma maneira fácil em um terminal Unix de obter apenas o endereço IP, em vez de procurar ifconfig?

Você pode escrever um script que retorna apenas o 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

Ou para sistema linux

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

hostname -i # Debian

Isso fornecerá todas as interfaces IPv4, incluindo o loopback 127.0.0.1:

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

Isso mostrará apenas eth0:

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

E desta forma você pode obter endereços IPv6:

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

Apenas eth0IPv6:

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

Geralmente, nunca é garantido que um sistema terá apenas um endereço IP, por exemplo, você pode ter conexões ethernet e wlan e, se tiver uma conexão VPN ativa, terá ainda outro endereço IP.

Linux

No Linux, hostname -Iirá listar o (s) endereço (s) IP atual (is). Contar com ele sempre retornando apenas um endereço IP provavelmente não funcionará como esperado em alguns cenários (ou seja, um link VPN está ativo), então uma maneira mais confiável seria converter o resultado em uma matriz e, em seguida, fazer um loop sobre os elementos:

ips=($(hostname -I))

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

OSX

No OSX, se você conhece a interface , pode usar:

~$ ipconfig getifaddr en0
192.168.1.123

que retornará apenas o endereço IP.

Ou você pode fazer um loop em nomes de interface possíveis, começando com um sufixo, ou seja en:

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

echo $myip

Além disso, obter o endereço IP torna-se não determinístico no caso de serem estabelecidas conexões de cabo e wifi, quando uma máquina tem mais de uma interface Ethernet ou quando túneis VPN estão presentes.

Obtendo o IP externo

Se você precisar do IP externo, poderá consultar um serviço em modo texto, por exemplo curl https://ipecho.net/plain, retornaria um IP externo em texto simples .

E uma maneira ainda mais rápida de obter o IP externo é consultar um servidor DNS conhecido:

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

hostname -I  

Este comando fornecerá o endereço IP exato que você deseja no Ubuntu.

Nas últimas versões do Ubuntu ( 14.04 - 16.04 ), este comando fez o truque para mim.

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

Se você tiver um ambiente limitado, pode usar este comando:

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

Para obter apenas o endereço IP no Mac OS X, você pode digitar o seguinte comando:

ipconfig getifaddr en0

O comando ifconfigestá desativado e você deve usarip comando no Linux.

Além disso ip a fornecerá escopo na mesma linha do IP, para que seja mais fácil de usar.

Este comando mostrará seu IP global (externo):

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

Todo IPv4 (também 127.0.0.1):

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

Todo IPv6 (também :: 1):

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

Podemos simplesmente usar apenas 2 comandos (ifconfig + awk) para obter apenas o IP (v4) que desejamos:

No Linux, presumindo que obterá o endereço IP da eth0interface, execute o seguinte comando:

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

No OSX, supondo que obterá o endereço IP da en0interface, execute o seguinte comando:

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

Para saber nosso IP público / externo, adicione esta função em ~/.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"
}

Então corra, whatismyip

Para imprimir apenas o endereço IP de eth0, sem outro texto:

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

Para determinar sua interface primária (porque pode não ser "eth0"), use:

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

As duas linhas acima podem ser combinadas em um único comando como este:

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

Eu queria algo simples que funcionasse como um apelido do Bash. Descobri que hostname -Ifunciona melhor para mim (hostname v3.15). hostname -iretorna o IP de loopback, por algum motivo, mas hostname -Ime dá o IP correto para wlan0, e sem ter que canalizar a saída através de grep ou awk. Uma desvantagem é que hostname -Iproduzirá todos os IPs, se você tiver mais de um.

Isso funcionaria em um Mac:

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

Isso resolveu ping 192.168.1.2na minha máquina.

Dica profissional : $(...)significa executar o que quer que esteja entre parênteses em um subshell e retornar isso como o valor.

Em man hostnamehá ainda mais fácil caminho que excluindo automaticamente loopback IP e mostrando apenas o espaço lista de todos atribuídos a endereços 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

Você também pode usar o seguinte comando:

ip route | grep src

NOTA: Isso só funcionará se você tiver conectividade com a Internet.

Poucas respostas parecem estar usando a mais recente ipde comandos (substituto para ifconfig) então aqui é aquele que usa ip addr, grepe awksimplesmente imprimir o endereço IPv4 associados à wlan0interface:

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

Embora não seja a solução mais compacta ou sofisticada, é (sem dúvida) fácil de entender (veja a explicação abaixo) e modificar para outros fins, como obter os últimos 3 octetos do endereço MAC como este:

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

Explicação: ip addr show wlan0 informações de saída associadas à interface de rede nomeada wlan0, que deve ser semelhante 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

Próxima grep inetfiltra as linhas que não contêm "inet" (IPv4 e IPv6 configuração) e grep -v inet6filtra as linhas restantes que fazer conter "inet6", o que deve resultar em uma única linha como esta:

    inet 172.18.18.1/24 brd 172.18.18.255 scope global noprefixroute wlan0

Por fim, o primeiro awkextrai o campo "172.18.18.1/24" e o segundo remove a abreviação da máscara de rede, deixando apenas o endereço IPv4.

Além disso, acho que vale a pena mencionar que, se você estiver fazendo scripts, muitas vezes existem muitas ferramentas mais ricas e / ou mais robustas para obter essas informações, que você pode querer usar. Por exemplo, se estiver usando Node.js existe ipaddr-linux, se estiver usando Ruby, existe linux-ip-parser, etc.

Veja também /unix/119269/how-to-get-ip-address-using-shell-script

Use o seguinte comando:

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

Aqui está minha versão, na qual você pode passar uma lista de interfaces, ordenadas por prioridade:

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

Portanto, se eu estiver conectado com VPN, Wifi e ethernet, meu endereço VPN (na interface tap0) será retornado. O script funciona em Linux e osx, e pode receber argumentos se você quiser sobrescrever IFLIST

Observe que se você quiser usar IPV6, terá que substituir 'inet' por 'inet6'.

Sempre acabo precisando disso nos momentos mais inesperados e, sem falhar, acabo procurando tópicos como esse no SO. Então, escrevi um script simples para obter endereços IPv4 via netstat, chamado echoip- você pode encontrá-lo aqui . O bash para endereços de rede é semelhante a este, mas também obtém seu endereço público 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

O echoipscript produz uma saída como esta:

$ echoip
public: 26.106.59.169
en0:    10.1.10.2

use este script de uma linha: 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 e linux (testado no Ubuntu) ambos funcionam.

Prefiro não usar awke tal em scripts .. iptem a opção de saída em JSON.

Se você deixar de fora $interface, obterá todos os endereços 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}'

mostra todos os seus ips

No Redhat de 64 bits, esse problema resolveu para mim.

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

Ao procurar seu endereço IP externo em um host com NAT, algumas respostas sugerem o uso de métodos baseados em HTTP, como ifconfig.mepor exemplo:

$ curl ifconfig.me/ip

Ao longo dos anos, tenho visto muitos desses sites irem e virem, acho esse método baseado em DNS mais robusto:

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

Eu tenho este apelido útil em meu ~/.bashrc:

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

Essas duas maneiras funcionaram para mim:

Para obter o endereço IP de sua interface eth0. Substitua eth0 no exemplo abaixo pelo nome de sua interface. ifconfig eth0 | grep -w "inet" | tr -s " " | cut -f3 -d" "

Usando hostname: Isso lhe dará o inet, ou seja, IPAddress do seu etho. usando -I fornecerá o valor inet de todas as interfaces onde esse valor estiver presente.

hostname -i

curl ifconfig.co 

Isso retorna apenas o endereço IP do seu sistema.

Eu usaria Hostname -Lpara obter apenas o IP para usar como variável em um script.