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 aver creato un nuovo contenitore?

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

L' --formatopzione di inspectviene in soccorso.

La sintassi del client Docker moderno è:

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

La sintassi del client Docker precedente è:

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

Questi comandi restituiranno l'indirizzo IP del contenitore Docker.

Come menzionato nei commenti: se sei su Windows, usa virgolette doppie "invece di virgolette singole 'attorno alle parentesi graffe.

È possibile utilizzare docker inspect <container id>.

Per esempio:

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

Prima ottenere l'ID contenitore:

docker ps

(La prima colonna è per l'ID contenitore)

Utilizzare l'ID contenitore per eseguire:

docker inspect <container ID>

In fondo, sotto "Impostazioni di rete", puoi trovare "Indirizzo IP"

O semplicemente fai:

docker inspect <container id> | grep "IPAddress"

docker inspect CONTAINER_ID | grep "IPAddress"

Puoi aggiungere -ia grep per ignorare il caso, quindi anche le seguenti funzioneranno:

docker inspect CONTAINER_ID | grep -i "IPaDDreSS"

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

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

Se stai usando docker-composeil 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 ~/.bashrcfile o in quello pertinente:

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

Quindi, per ottenere un indirizzo IP di un contenitore, basta fare questo:

docker-ip YOUR_CONTAINER_ID

Per la nuova versione della Docker, utilizzare quanto segue:

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

Mostra tutti gli indirizzi IP del container:

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

In Docker 1.3+, puoi anche controllarlo usando:

Inserisci il Docker in esecuzione (Linux):

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

Per windows:

docker exec [container-id or container-name] ipconfig

A partire dalla versione Docker 1.10.3, compilare 20f81dd

Salvo diversamente specificato da Docker, Docker avvia sempre i container nella rete bridge. Quindi puoi provare questo comando qui sotto:

docker network inspect bridge

Che dovrebbe quindi restituire una sezione Containers che visualizzerà l'indirizzo IP per quel container 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

Verranno visualizzate le immagini docker attive:

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

Utilizzare il valore ID CONTAINER:

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

"172.17.0.2"

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

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)

Ho scritto il seguente script Bash per ottenere una tabella di indirizzi IP da tutti i contenitori in esecuzione 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 con il proprio nome di rete.

Ecco una risposta rapida:

Ottieni il nome o l'ID del contenitore:

docker container ls

Quindi ottenere l'IP:

docker inspect <container_ID Or container_name> |grep 'IPAddress'

Ottieni il porto:

docker inspect <container_ID Or container_name> |grep 'Port'

Docker è scritto in Go e utilizza la sintassi Go anche per scopi di query.

Per controllare l'indirizzo IP di un particolare contenitore, è necessario eseguire il comando ( -fper "formato"):

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

Per l'ID contenitore o il nome, è possibile eseguire il comando

docker container ls

che elencherà ogni container in esecuzione.

Ecco una soluzione che ho sviluppato oggi in Python, utilizzando l' docker inspect containeroutput JSON come origine dati.

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

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 è:

$ 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 }}' <containername or containerID here>

Quanto sopra funziona se il contenitore è distribuito sulla rete bridge predefinita.

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

docker exec <containername or containerID here> /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 container e i loro indirizzi IP:

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

Uso questo modo semplice

docker exec -it <container id or name> hostname -i

per esempio

ubuntu@myhost:~$ docker exec -it 3d618ac670fe hostname -i
10.0.1.5

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

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

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

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

Produzione:

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

NOTA!!! per Docker Compose Usage:

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

Il modo più elegante e semplice è definire una funzione shell, attualmente la risposta più votata @ WouterD's :

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

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

In esecuzione con --cidfile=filename , Docker scarica l'ID del contenitore su "nome file".

Vedere " Docker esegue la sezione equivalente PID " per ulteriori informazioni.

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

Utilizzando un file PID:

1. Eseguendo il contenitore con --cidfileparametro, il app.cidcontenuto del file è simile a:

   a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909
   

2. È possibile utilizzare il contenuto del file per ispezionare i contenitori Docker:

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

3. Puoi estrarre l'IP del contenitore usando uno script Python in linea:

   $ 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
   

Ecco una forma più 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 <CONTAINER ID> | get-docker-ip.py

import json
import sys

sys.stdout.write(json.load(sys.stdin)[0]['NetworkSettings']['IPAddress'])

Vedere " 10 alternative per ottenere gli indirizzi IP del contenitore Docker " per ulteriori informazioni.

Per Windows 10:

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

Questo elencherà tutti gli IP del contenitore sull'host:

sudo docker ps -aq | while read line;  do sudo docker inspect -f '{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $line ; done

Docker ispeziona l'uso per stampare tutti i container ips e i rispettivi nomi

docker ps -q | xargs -n 1 docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}} {{ .Name }}' | sed 's/ \// /'

Solo per completezza:

Mi piace molto l' --formatopzione, ma all'inizio non ne ero a conoscenza, quindi ho usato un semplice one-liner Python per ottenere lo stesso risultato:

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

Combinazione di risposte precedenti con la ricerca dell'ID contenitore in base al nome dell'immagine Docker:

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

Uso:

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

Per i contenitori di Windows utilizzare

docker exec <container> ipconfig

dove <container>è il nome o l' id del contenitore.

È possibile utilizzare docker psper trovare l'id del contenitore.

Se hai dimenticato l'ID contenitore o non vuoi manipolare 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

Lì puoi trovare tutte le informazioni sul contenitore anche IP.