So erhalten Sie die IP-Adresse eines Docker-Containers vom Host

Gibt es einen Befehl, den ich ausführen kann, um die IP-Adresse des Containers direkt vom Host abzurufen, nachdem ein neuer Container erstellt wurde?

Grundsätzlich möchte ich nach dem Erstellen des Containers durch Docker meine eigenen Skripts für die Codebereitstellung und Containerkonfiguration erstellen.

Die --formatOption inspectkommt zur Rettung.

Die moderne Docker-Client-Syntax lautet:

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

Die alte Docker-Client-Syntax lautet:

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

Diese Befehle geben die IP-Adresse des Docker-Containers zurück.

Wie in den Kommentaren erwähnt: Wenn Sie unter Windows arbeiten, verwenden Sie doppelte Anführungszeichen "anstelle von einfachen Anführungszeichen 'um die geschweiften Klammern.

Sie können verwenden docker inspect <container id>.

Zum Beispiel:

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

Holen Sie sich zuerst die Container-ID:

docker ps

(Die erste Spalte enthält die Container-ID.)

Verwenden Sie die Container-ID, um Folgendes auszuführen:

docker inspect <container ID>

Unten unter "NetworkSettings" finden Sie "IPAddress".

Oder machen Sie einfach:

docker inspect <container id> | grep "IPAddress"

docker inspect CONTAINER_ID | grep "IPAddress"

Sie können -igrep hinzufügen , um den Fall zu ignorieren, dann funktioniert sogar Folgendes:

docker inspect CONTAINER_ID | grep -i "IPaDDreSS"

Um alle Containernamen und ihre IP-Adressen in nur einem Befehl abzurufen.

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

Wenn Sie docker-composeden Befehl verwenden, lautet dieser:

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

Die Ausgabe wird sein:

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

Fügen Sie dieses Shell-Skript in Ihre ~/.bashrcoder eine relevante Datei ein:

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

Um eine IP-Adresse eines Containers zu erhalten, gehen Sie einfach wie folgt vor:

docker-ip YOUR_CONTAINER_ID

Verwenden Sie für die neue Version des Docker Folgendes:

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

Alle IP-Adressen des Containers anzeigen:

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

In Docker 1.3+ können Sie dies auch überprüfen mit:

Geben Sie den laufenden Docker (Linux) ein:

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

Für Windows:

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

Erstellen Sie ab Docker Version 1.10.3 20f81dd

Sofern Sie Docker nichts anderes mitgeteilt haben, startet Docker Ihre Container immer im Brückennetzwerk. So können Sie diesen Befehl unten versuchen:

docker network inspect bridge

Daraufhin sollte ein Container-Abschnitt zurückgegeben werden, in dem die IP-Adresse für diesen laufenden Container angezeigt wird.

[
    {
        "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"
        }
    }
]

Ausführen:

docker ps -a

Dadurch werden aktive Docker-Bilder angezeigt:

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

Verwenden Sie den CONTAINER ID-Wert:

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

172.17.0.2

Basierend auf einigen der Antworten, die ich geliebt habe, habe ich beschlossen, sie zu einer Funktion zusammenzuführen, um alle IP-Adressen und eine andere für einen bestimmten Container abzurufen. Sie sind jetzt in meiner .bashrcAkte.

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

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

Der erste Befehl gibt die IP-Adresse aller Container und der zweite die IP-Adresse eines bestimmten Containers an.

docker-ips
docker-ip YOUR_CONTAINER_ID

Referenzcontainer nach Namen:

docker run ... --name pg-master

Dann holen Sie sich die IP-Adresse nach Namen:

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

Ich habe das folgende Bash-Skript geschrieben, um eine Tabelle mit IP-Adressen von allen Containern abzurufen, unter denen ausgeführt wird 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
}

Sie sollten das variable Netzwerk in Ihren eigenen Netzwerknamen ändern.

Hier ist eine schnelle Antwort:

Holen Sie sich Ihren Containernamen oder Ihre ID:

docker container ls

Dann holen Sie sich die IP:

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

Holen Sie sich den Hafen:

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

Docker ist in Go geschrieben und verwendet die Go-Syntax auch für Abfragezwecke.

Um die IP-Adresse eines bestimmten Containers zu überprüfen, müssen Sie den folgenden Befehl ausführen ( -ffür "Format"):

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

Für die Container-ID oder den Namen können Sie den Befehl ausführen

docker container ls

Dadurch wird jeder laufende Container aufgelistet.

Hier ist eine Lösung, die ich heute in Python entwickelt habe und die die docker inspect containerJSON-Ausgabe als Datenquelle verwendet.

Ich habe viele Container und Infrastrukturen, die ich überprüfen muss, und ich muss grundlegende Netzwerkinformationen von jedem Container schnell und hübsch abrufen abrufen. Deshalb habe ich dieses Skript erstellt.

WICHTIG: Seit Version 1.9 können Sie mit Docker mehrere Netzwerke erstellen und an die Container anhängen.

#!/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'])

Die Ausgabe ist:

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

Das Obige funktioniert, wenn der Container im Standardbrückennetzwerk bereitgestellt wird.

Wenn Sie jedoch ein benutzerdefiniertes Brückennetzwerk oder ein Overlay-Netzwerk verwenden, funktioniert das Folgende besser:

docker exec <containername or containerID here> /sbin/ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'

Um die Antwort von ko-dos zu erweitern, ist hier ein Alias, um alle Containernamen und ihre IP-Adressen aufzulisten:

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'

Ich benutze diesen einfachen Weg

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

z.B

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

Wenn Sie Docker mithilfe der Docker Toolbox installiert haben, können Sie die Kitematic-Anwendung verwenden, um die Container-IP-Adresse abzurufen:

1. Wählen Sie den Container aus
2. Klicken Sie auf Einstellungen
3. Klicken Sie auf die Registerkarte Ports.

So erhalten Sie die IP-Adresse und den Host-Port eines Containers:

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

Ausgabe:

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

HINWEIS!!! für die Verwendung von Docker Compose:

Da Docker Compose für jeden Cluster ein isoliertes Netzwerk erstellt, funktionieren die folgenden Methoden nicht docker-compose.

Der eleganteste und einfachste Weg ist die Definition einer Shell-Funktion, derzeit die am häufigsten gewählte Antwort bei WouterD :

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

Docker kann Container-IDs in eine Datei wie Linux-Programme schreiben:

Laufen mit --cidfile=filename , Deponien Docker die ID des Containers „Dateiname“.

Weitere Informationen finden Sie im Abschnitt " Docker führt PID-äquivalente Abschnitte aus ".

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

Verwenden einer PID-Datei:

1. Wenn der Container mit einem --cidfileParameter ausgeführt wird, sieht der app.cidDateiinhalt folgendermaßen aus:

   a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909
   

2. Sie können Dateiinhalte verwenden, um Docker-Container zu überprüfen:

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

3. Sie können die Container-IP mithilfe eines Inline-Python-Skripts extrahieren:

   $ 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
   

Hier ist eine menschlichere Form:

#!/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'])

Weitere Informationen finden Sie unter " 10 Alternativen zum Abrufen der Docker-Container-IP-Adressen ".

Für Windows 10:

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

Dadurch werden alle Container-IPs auf dem Host aufgelistet:

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

Docker inspect verwendet, um alle Container-IPs und ihre jeweiligen Namen zu drucken

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

Nur der Vollständigkeit halber:

Ich mag die --formatOption wirklich , aber zuerst war ich mir dessen nicht bewusst, also habe ich einen einfachen Python-Einzeiler verwendet, um das gleiche Ergebnis zu erzielen:

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

Kombinieren früherer Antworten mit dem Finden der Container-ID basierend auf dem Docker-Image-Namen:

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

Verwenden:

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

Für Windows-Container verwenden

docker exec <container> ipconfig

Wo <container>ist der Name oder die ID des Containers

Sie können verwenden docker ps, um die ID des Containers zu finden.

Wenn Sie die Container-ID vergessen haben oder nicht mit Shell-Befehlen bearbeiten möchten, ist es besser, eine Benutzeroberfläche wie Portainer zu verwenden.

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

Dort finden Sie alle Informationen zum Container auch IP.