Come ottenere l’indirizzo IP di un container Docker dall’host?

Esiste un comando che posso eseguire per ottenere l’indirizzo IP del contenitore direttamente dall’host dopo la creazione di un nuovo contenitore?

Fondamentalmente, una volta che il Docker crea il contenitore, voglio eseguire il rolloff della mia distribuzione del codice e degli script di configurazione del contenitore.

L’opzione --format di --format viene in soccorso.

Sintassi del client Docker moderna:

 docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' container_name_or_id 

Sintassi del client Old Docker:

 docker inspect --format '{{ .NetworkSettings.IPAddress }}' container_name_or_id 

Che restituirà solo l’indirizzo IP.

Puoi usare la docker inspect

Esempio:

 CID=$(docker run -d -p 4321 base nc -lk 4321); docker inspect $CID 

Per prima cosa prendi l’ID del contenitore:

 docker ps 

(La prima colonna è per l’ID contenitore)

Utilizza l’ID contenitore per eseguire:

 docker inspect  

In basso, sotto “NetworkSettings”, puoi trovare “Indirizzo IP”

O fai semplicemente:

 docker inspect  | grep "IPAddress" 

docker inspect | grep "IPAddress"

Per ottenere tutti i nomi dei contenitori e i loro indirizzi IP in un solo comando.

 docker inspect -f '{{.Name}} - {{.NetworkSettings.IPAddress }}' $(docker ps -aq) 

Se stai usando docker-compose il comando sarà questo:

 docker inspect -f '{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -aq) 

L’output sarà:

 /containerA - 172.17.0.4 /containerB - 172.17.0.3 /containerC - 172.17.0.2 

Aggiungi questo script di shell nel tuo ~/.bashrc o file pertinente:

 docker-ip() { docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$@" } 

Quindi, per ottenere un indirizzo IP di un contenitore, fallo semplicemente:

 docker-ip YOUR_CONTAINER_ID 

Per la nuova versione di Docker, utilizzare quanto segue:

 docker-ip() { docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$@" } 

Mostra tutti gli indirizzi IP dei contenitori:

 docker inspect --format='{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -aq) 

In Docker 1.3+, puoi anche controllarlo tramite i passaggi seguenti:

Inserisci la finestra mobile in esecuzione:

 docker exec [container-id or container-name] cat /etc/hosts 172.17.0.26 d8bc98fa4088 127.0.0.1 localhost ::1 localhost ip6-localhost ip6-loopback fe00::0 ip6-localnet ff00::0 ip6-mcastprefix ff02::1 ip6-allnodes ff02::2 ip6-allrouters 172.17.0.17 mysql 

A partire da Docker versione 1.10.3, compilare 20f81dd

A meno che tu non abbia detto diversamente a Docker, Docker avvia sempre i tuoi contenitori nella rete bridge. Quindi puoi provare questo comando qui sotto:

 docker network inspect bridge 

Quale dovrebbe quindi restituire una sezione Containers che visualizzerà l’indirizzo IP per quel contenitore in esecuzione.

 [ { "Name": "bridge", "Id": "40561e7d29a08b2eb81fe7b02736f44da6c0daae54ca3486f75bfa81c83507a0", "Scope": "local", "Driver": "bridge", "IPAM": { "Driver": "default", "Options": null, "Config": [ { "Subnet": "172.17.0.0/16" } ] }, "Containers": { "025d191991083e21761eb5a56729f61d7c5612a520269e548d0136e084ecd32a": { "Name": "drunk_leavitt", "EndpointID": "9f6f630a1743bd9184f30b37795590f13d87299fe39c8969294c8a353a8c97b3", "IPv4Address": "172.17.0.2/16", "IPv6Address": "" } }, "Options": { "com.docker.network.bridge.default_bridge": "true", "com.docker.network.bridge.enable_icc": "true", "com.docker.network.bridge.enable_ip_masquerade": "true", "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0", "com.docker.network.bridge.name": "docker0", "com.docker.network.driver.mtu": "1500" } } ] 

Eseguire:

 docker ps -a 

Questo mostrerà le immagini attive della finestra mobile:

 CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 3b733ae18c1c parzee/database "/usr/lib/postgresql/" 6 minutes ago Up 6 minutes 5432/tcp serene_babbage 

Usa il valore ID CONTENITORE:

 docker inspect  | grep -w "IPAddress" | awk '{ print $2 }' | head -n 1 | cut -d "," -f1 

“172.17.0.2”

Sulla base di alcune delle risposte che ho amato, ho deciso di unirle a una funzione per ottenere tutti gli indirizzi IP e un’altra per un contenitore specifico. Ora sono nel mio file .bashrc .

 docker-ips() { docker inspect --format='{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -aq) } docker-ip() { docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$@" } 

Il primo comando fornisce l’indirizzo IP di tutti i contenitori e il secondo l’indirizzo IP di un contenitore specifico.

 docker-ips docker-ip YOUR_CONTAINER_ID 

Contenitori di riferimento per nome:

 docker run ... --name pg-master 

Quindi prendi l’indirizzo IP per nome:

 MASTER_HOST=$(docker inspect --format '{{ .NetworkSettings.IPAddress }}' pg-master) 

Docker è realizzato internamente in Go e utilizza la syntax Go anche a fini di query.

Per ispezionare l’indirizzo IP di un determinato contenitore, è necessario eseguire il comando (-f per l’opzione di formato)

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' container_id_or_name

Per l’ID contenitore o il nome, è ansible eseguire il comando docker container ls . Elencherà in basso ogni contenitore funzionante.

Ho scritto il seguente script Bash per ottenere una tabella di indirizzi IP da tutti i contenitori in esecuzione sotto la docker-compose .

 function docker_container_names() { docker ps -a --format "{{.Names}}" | xargs } # Get the IP address of a particular container dip() { local network network='YOUR-NETWORK-HERE' docker inspect --format "{{ .NetworkSettings.Networks.$network.IPAddress }}" "$@" } dipall() { for container_name in $(docker_container_names); do local container_ip=$(dip $container_name) if [[ -n "$container_ip" ]]; then echo $(dip $container_name) " $container_name" fi done | sort -t . -k 3,3n -k 4,4n } 

È necessario modificare la rete variabile sul proprio nome di rete.

Ecco una soluzione che ho sviluppato oggi in Python, utilizzando l’output JSON “docker inspect container” come origine dati.

Ho un sacco di container e infrastrutture che devo ispezionare, e ho bisogno di ottenere informazioni di base sulla rete da qualsiasi contenitore, in modo rapido e carino . Ecco perché ho realizzato questo script.

IMPORTANTE: dalla versione 1.9, Docker consente di creare più reti e collegarle ai contenitori.

 #!/usr/bin/python import json import subprocess import sys try: CONTAINER = sys.argv[1] except Exception as e: print "\n\tSpecify the container name, please." print "\t\tEx.: script.py my_container\n" sys.exit(1) # Inspecting container via Subprocess proc = subprocess.Popen(["docker","inspect",CONTAINER], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) out = proc.stdout.read() json_data = json.loads(out)[0] net_dict = {} for network in json_data["NetworkSettings"]["Networks"].keys(): net_dict['mac_addr'] = json_data["NetworkSettings"]["Networks"][network]["MacAddress"] net_dict['ipv4_addr'] = json_data["NetworkSettings"]["Networks"][network]["IPAddress"] net_dict['ipv4_net'] = json_data["NetworkSettings"]["Networks"][network]["IPPrefixLen"] net_dict['ipv4_gtw'] = json_data["NetworkSettings"]["Networks"][network]["Gateway"] net_dict['ipv6_addr'] = json_data["NetworkSettings"]["Networks"][network]["GlobalIPv6Address"] net_dict['ipv6_net'] = json_data["NetworkSettings"]["Networks"][network]["GlobalIPv6PrefixLen"] net_dict['ipv6_gtw'] = json_data["NetworkSettings"]["Networks"][network]["IPv6Gateway"] for item in net_dict: if net_dict[item] == "" or net_dict[item] == 0: net_dict[item] = "null" print "\n[%s]" % network print "\n{}{:>13} {:>14}".format(net_dict['mac_addr'],"IP/NETWORK","GATEWAY") print "--------------------------------------------" print "IPv4 settings:{:>16}/{:<5} {}".format(net_dict['ipv4_addr'],net_dict['ipv4_net'],net_dict['ipv4_gtw']) print "IPv6 settings:{:>16}/{:<5} {}".format(net_dict['ipv6_addr'],net_dict['ipv6_net'],net_dict['ipv6_gtw']) 

L'output è proprio così:

 $ python docker_netinfo.py debian1 [frontend] 02:42:ac:12:00:02 IP/NETWORK GATEWAY -------------------------------------------- IPv4 settings: 172.18.0.2/16 172.18.0.1 IPv6 settings: null/null null [backend] 02:42:ac:13:00:02 IP/NETWORK GATEWAY -------------------------------------------- IPv4 settings: 172.19.0.2/16 172.19.0.1 IPv6 settings: null/null null 
 docker inspect --format '{{ .NetworkSettings.IPAddress }}'  

Quanto sopra funziona se il contenitore viene distribuito nella rete bridge predefinita.

Tuttavia, se si utilizza una rete bridge personalizzata o una rete overlay, ho trovato il seguente per funzionare meglio:

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

Per estendere la risposta di ko-dos, ecco un alias per elencare tutti i nomi dei contenitori e i loro indirizzi IP:

 alias docker-ips='docker ps | tail -n +2 | while read -aa; do name=${a[$((${#a[@]}-1))]}; echo -ne "$name\t"; docker inspect $name | grep IPAddress | cut -d \" -f 4; done' 

Se hai installato Docker utilizzando Docker Toolbox, puoi utilizzare l’applicazione Kitematic per ottenere l’indirizzo IP del contenitore:

  1. Seleziona il contenitore
  2. Clicca su Impostazioni
  3. Fare clic sulla scheda Porte.

NOTA!!! per l’utilizzo di Docker Compose:

Poiché Docker Compose crea una rete isolata per ciascun cluster, i seguenti metodi non funzionano con la docker-compose .


Il modo più elegante e semplice è definire una funzione shell come la risposta più votata @ WouterD :

 dockip() { docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$@" } 

Docker può scrivere id contenitore in un file come i programmi Linux:

Eseguendo con --cidfile=filename parametro --cidfile=filename , Docker scarica l’ID del contenitore in questo file.

La finestra mobile esegue la sezione equivalente PID

 --cidfile="app.cid": Write the container ID to the file 

Utilizzando il file PID

  1. L’esecuzione del contenitore con il parametro --cidfile , il contenuto del file app.cid è come indicato di seguito:

a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909

  1. È ansible utilizzare il contenuto del file per ispezionare i contenitori Docker:

    ➜ blog-v4 git:(develop) ✗ docker inspect `cat app.cid`

  2. Estrazione dello script Python inline IP del contenitore:

    $ docker inspect `cat app.cid` | python -c "import json;import sys;\ sys.stdout.write(json.load(sys.stdin)[0]['NetworkSettings']['IPAddress'])" 172.17.0.2


Più forma umana

 #!/usr/bin/env python # Coding: utf-8 # Save this file like get-docker-ip.py in a folder that in $PATH # Run it with # $ docker inspect  | get-docker-ip.py import json import sys sys.stdout.write(json.load(sys.stdin)[0]['NetworkSettings']['IPAddress']) 

http://networkstatic.net/10-examples-of-how-to-get-docker-container-ip-address/

Qui ci sono 10 alternative per ottenere gli indirizzi IP del contenitore Docker.

Per Windows 10:

 docker inspect --format "{{ .NetworkSettings.IPAddress }}" containerId 

Solo per completezza:

Mi piace molto l’opzione –format , ma all’inizio non ero a conoscenza di questa opzione, quindi ho usato un semplice liner Python per ottenere lo stesso risultato:

 docker inspect  |python -c 'import json,sys;obj=json.load(sys.stdin);print obj[0]["NetworkSettings"]["IPAddress"]' 

Per ottenere l’indirizzo IP e la porta host di un contenitore:

 docker inspect conatinerId | awk '/IPAddress/ || /HostPort/' 

Produzione:

  "HostPort": "4200" "HostPort": "4200" "SecondaryIPAddresses": null, "IPAddress": "172.17.0.2", "IPAddress": "172.17.0.2", 

Combinare le risposte precedenti con la ricerca dell’ID contenitore in base al nome dell’immagine del Docker.

 docker inspect --format '{{ .NetworkSettings.IPAddress }}' `docker ps | grep $IMAGE_NAME | sed 's/\|/ /' | awk '{print $1}'` 

Per coloro che sono venuti da Google per trovare la soluzione per l’esecuzione del comando da terminale (non da script), jid (un drill-down JSON interattivo con completamento automatico e suggerimento) consente di ottenere la stessa cosa con una minore digitazione.

 docker inspect $CID | jid 

Digita la scheda .Net tab e vedrai quanto segue:

 [Filter]> .[0].NetworkSettings { "Bridge": "", "EndpointID": "b69eb8bd4f11d8b172c82f21ab2e501fe532e4997fc007ed1a997750396355d5", "Gateway": "172.17.0.1", "GlobalIPv6Address": "", "GlobalIPv6PrefixLen": 0, "HairpinMode": false, "IPAddress": "172.17.0.2", "IPPrefixLen": 16, "IPv6Gateway": "", "LinkLocalIPv6Address": "", "LinkLocalIPv6PrefixLen": 0, "MacAddress": "02:42:ac:11:00:02", "Networks": { "bridge": { "Aliases": null, "EndpointID": "b69eb8bd4f11d8b172c82f21ab2e501fe532e4997fc007ed1a997750396355d5", "Gateway": "172.17.0.1", "GlobalIPv6Address": "", 

Digita la scheda .IPA e vedrai quanto segue:

 [Filter]> .[0].NetworkSettings.IPAddress "172.17.0.2" 

Uso:

 docker inspect $CID | grep IPAddress | grep -v null| cut -d '"' -f 4 | head -1 

Utilizzare i contenitori di Windows

 docker exec  ipconfig 

dove è il nome o l’ id del contenitore.

Puoi usare la docker ps per trovare l’id del contenitore.

Se hai dimenticato l’ID del contenitore o non vuoi manipolarlo con i comandi della shell, è meglio usare l’interfaccia utente come Portainer.

https://portainer.io/

 $ docker volume create portainer_data $ docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer 

Qui puoi trovare tutte le informazioni sul contenitore anche IP.

Ispezionare non ha funzionato per me. Forse come stavo usando -net host e alcuni namespace.

Comunque, ho trovato che funziona bene:

 docker exec -i -t NAME /sbin/ifconfig docker0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}' 

Ho dovuto estrarre l’indirizzo IP del contenitore docker dal nome del contenitore docker per un ulteriore utilizzo negli script di distribuzione. A questo scopo ho scritto il seguente comando bash:

 docker inspect $(sudo docker ps | grep my_container_name | head -c 12) | grep -e \"IPAddress\"\:[[:space:]]\"[0-2] | grep -o '[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}' 

Supponiamo che potrebbe essere utile metterlo in uno script bash, che si aspetterebbe my_container_name come argomento …

 docker inspect  | grep -i ip 

Per esempio:

 docker inspect 2b0c4b617a8c | grep -i ip