webentwicklung-frage-antwort-db.com.de

Wie erhalte ich 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.

1143
Murali Allada

Die Inspektionsoption --format hilft dabei.

Moderne Docker-Client-Syntax:

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

Alte Docker-Client-Syntax:

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

Welches wird nur die IP-Adresse zurückgeben.

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

1832
WouterD

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

Beispiel:

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

Holen Sie sich zuerst die Container-ID:

docker ps

(Die erste Spalte ist für 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"
366
Krunal

docker inspect CONTAINER_ID | grep "IPAddress"

Wenn Sie -i zu grep hinzufügen, kann die IPAddress-Groß-/Kleinschreibung folgendermaßen aussehen:

docker inspect CONTAINER_ID | grep -i "IPADDress"

182
nPcomp

Abrufen aller Containernamen und ihrer IP-Adressen in einem einzigen Befehl.

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

Wenn Sie docker-compose verwenden, lautet der Befehl wie folgt:

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
103
Hemerson Varela

Fügen Sie dieses Shell-Skript in Ihrem ~/.bashrc oder in der entsprechenden Datei hinzu:

docker-ip() {
  docker inspect --format '{{ .NetworkSettings.IPAddress }}' "[email protected]"
}

Gehen Sie folgendermaßen vor, um eine IP-Adresse eines Containers abzurufen:

docker-ip YOUR_CONTAINER_ID

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

docker-ip() {
        docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "[email protected]"
}
92
Tuong Le

Alle Container IP-Adressen anzeigen:

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

In Docker 1.3+ können Sie dies auch anhand der folgenden Schritte überprüfen:

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
32
Jake W

Erstellen Sie ab Docker Version 1.10.3 20f81dd

Sofern Sie Docker nichts anderes mitgeteilt haben, startet Docker Ihre Container immer im Bridge-Netzwerk. So können Sie diesen Befehl unten versuchen:

docker network inspect bridge

Daraufhin sollte ein Abschnitt "Container" zurückgegeben werden, in dem die IP-Adresse des ausgeführten Containers 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"
        }
    }
]
23
Athena

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 Wert CONTAINER ID:

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

172.17.0.2

22
user260826

Aufgrund einiger der von mir geliebten Antworten habe ich beschlossen, sie zu einer Funktion zusammenzuführen, um alle IP-Adressen und eine weitere für einen bestimmten Container abzurufen. Sie befinden sich jetzt in meiner .bashrc -Datei.

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

docker-ip() {
  docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "[email protected]"
}

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
20
silgon

Referenzbehälter 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)
16
Sameer C

Ich habe das folgende Bash-Skript geschrieben, um eine Tabelle mit IP-Adressen aus allen Containern zu erhalten, die unter docker-compose ausgeführt werden.

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

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.

14
Dunk

Docker wird intern in Go erstellt und verwendet die Go-Syntax auch für Abfragezwecke.

Um die IP-Adresse eines bestimmten Containers zu überprüfen, müssen Sie den Befehl ausführen (-f für Formatoption).

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 docker container ls ausführen. Es listet jeden laufenden Container auf.

13
Rushal Verma

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

Ich habe viele Container und Infrastrukturen, die ich untersuchen muss, und ich muss grundlegende Netzwerkinformationen von jedem Container schnell und auf hübsche Weise abrufen. Deshalb habe ich dieses Skript gemacht.

WICHTIG: Seit Version 1.9 können Sie in Docker mehrere Netzwerke erstellen und diese 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 sieht einfach so aus:

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

Schnelle Antwort (Dies funktioniert):

Holen Sie sich Ihren Container Name oder ID:

docker container ls

Dann mach es (IP holen):

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

Port holen:

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

9
Benyamin Jafari
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 Folgendes besser:

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

Um die Antwort von ko-dos zu erweitern, finden Sie hier einen Alias, in dem alle Containernamen und ihre IP-Adressen aufgelistet sind:

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'
8
Marco Roy

Wenn Sie Docker mit Docker Toolbox installiert haben, können Sie die Container-IP-Adresse mit der Kitematic-Anwendung ermitteln:

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

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

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

Ausgabe:

    "HostPort": "4200"
                    "HostPort": "4200"
        "SecondaryIPAddresses": null,
        "IPAddress": "172.17.0.2",
                "IPAddress": "172.17.0.2",
7
Raj Asapu

Für Windows 10:

docker inspect --format "{{ .NetworkSettings.IPAddress }}"  containerId
6
Hai Nguyen

HINWEIS !!! für Docker Compose Usage:

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


Am elegantesten und einfachsten ist es, eine Shell-Funktion als die am häufigsten gewählte Antwort zu definieren @ WouterD's :

dockip() {
  docker inspect --format '{{ .NetworkSettings.IPAddress }}' "[email protected]"
}

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

Docker führt den Parameter --cidfile=filename aus und speichert die ID des Containers in dieser Datei.

Docker führt den PID-äquivalenten Abschnitt aus

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

PID-Datei verwenden

  1. Das Ausführen des Containers mit dem Parameter --cidfile und dem Dateiinhalt app.cid sieht wie folgt aus:

a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909

  1. Mithilfe des Dateiinhalts können Sie Docker-Container untersuchen:

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

  2. Extrahieren des Container-IP-Inline-Skripts Python:

    $ 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


Mehr menschlich freundliche 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'])

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

Hier gibt es 10 Alternativen zum Abrufen der Docker-Container-IP-Adressen.

6
guneysus

Nur der Vollständigkeit halber:

Die Option - format gefällt mir sehr gut, aber zuerst war mir diese Option nicht bekannt. Daher 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"]'
5
sedi

Kombinieren von vorherigen 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}'`
4
Gene Hazan

Wenn Sie die Container-ID vergessen haben oder nicht mit Shell-Befehlen manipulieren 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 zu Container auch IP.

4
igor

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/ \// /'
4
KARTHIKEYAN.A

Für Windows Container verwenden

docker exec <container> ipconfig

dabei ist <container> das Name oder das ID des Containers.

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

4
kirodge

Verwenden:

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

Dies listet alle Container-IPs auf dem Host auf:

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

Bisher hat noch niemand die Docker Python-API vorgeschlagen. Die Docker-API-Lösung zum Abrufen der IP-Adresse ist recht einfach.

* NIX-basiertes Betriebssystem: docker api 3.7 (aktualisiert dank canadadry aus den Kommentaren)

import docker

client = docker.DockerClient(base_url='unix://var/run/docker.sock')
x_container = client.containers(filters={"name":"x_container"})[0]
x_ip_addr = x_container["NetworkSettings"]["Networks"]["NETWORK_NAME"]["IPAddress"]

OS Agnostic: docker api 4.0.x (hinzugefügt dank pds aus den Kommentaren)

import docker

client = docker.from_env()
container = client.containers.get(container_name)
vars( container )["attrs"]["NetworkSettings"]["Networks"]["<NETWORK_NAME>"]["IPAddress"]

War nicht zu schwer zu finden, ist aber nützlich. Zusätzlich kann dies leicht geändert werden, um alle IPs zu finden, die einem Container in verschiedenen Netzwerken zugewiesen sind.

4
Procyclinsur

Für diejenigen, die von Google kamen, um eine Lösung für die Befehlsausführung über das Terminal zu finden (nicht per Skript), können Sie mit jid (einem interaktiven JSON-Drilldown mit Autocomplete und Suggestion) dasselbe mit weniger Tippaufwand erreichen.

docker inspect $CID | jid

Art tab .Netz tab und du wirst folgendes sehen:

[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": "",

Geben Sie .IPA ein tab und du wirst folgendes sehen:

[Filter]> .[0].NetworkSettings.IPAddress
"172.17.0.2"
4
Joel Handwell
docker inspect <container id> | grep -i ip

Zum Beispiel:

docker inspect 2b0c4b617a8c | grep -i ip
3
Roman

Die akzeptierte Antwort funktioniert nicht gut mit mehreren Netzwerken pro Container:

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

172.20.0.4172.18.0.5

Die nächstbeste Antwort ist näher:

> docker inspect cc54d96d63ea | grep "IPAddress"

"SecondaryIPAddresses": null,
"IPAddress": "",
    "IPAddress": "172.20.0.4",
    "IPAddress": "172.18.0.5",

Ich verwende jq, um das Netzwerk-JSON zu analysieren:

> docker inspect cc54d96d63ea | jq -r 'map(.NetworkSettings.Networks) []'

{
  "proxy": {
    "IPAMConfig": null,
    "Links": [
      "server1_php_1:php",
      "server1_php_1:php_1",
      "server1_php_1:server1_php_1"
    ],
    "Aliases": [
      "cc54d96d63ea",
      "web"
    ],
    "NetworkID": "7779959d7383e9cef09c970c38c24a1a6ff44695178d314e3cb646bfa30d9935",
    "EndpointID": "4ac2c26113bf10715048579dd77304008904186d9679cdbc8fcea65eee0bf13b",
    "Gateway": "172.20.0.1",
    "IPAddress": "172.20.0.4",
    "IPPrefixLen": 24,
    "IPv6Gateway": "",
    "GlobalIPv6Address": "",
    "GlobalIPv6PrefixLen": 0,
    "MacAddress": "02:42:ac:14:00:04",
    "DriverOpts": null
  },
  "webservers": {
    "IPAMConfig": null,
    "Links": [
      "server1_php_1:php",
      "server1_php_1:php_1",
      "server1_php_1:server1_php_1"
    ],
    "Aliases": [
      "cc54d96d63ea",
      "web"
    ],
    "NetworkID": "907a7fba8816cd0ad89b7f5603bbc91122a2dd99902b504be6af16427c11a0a6",
    "EndpointID": "7febabe380d040b96b4e795417ba0954a103ac3fd37e9f6110189d9de92fbdae",
    "Gateway": "172.18.0.1",
    "IPAddress": "172.18.0.5",
    "IPPrefixLen": 24,
    "IPv6Gateway": "",
    "GlobalIPv6Address": "",
    "GlobalIPv6PrefixLen": 0,
    "MacAddress": "02:42:ac:12:00:05",
    "DriverOpts": null
  }
}

So listen Sie die IP-Adressen jedes Containers auf:

for s in `docker ps -q`; do
  echo `docker inspect -f "{{.Name}}" ${s}`:
  docker inspect ${s} | jq -r 'map(.NetworkSettings.Networks) []' | grep "IPAddress";
done

/server1_web_1:
    "IPAddress": "172.20.0.4",
    "IPAddress": "172.18.0.5",
/server1_php_1:
    "IPAddress": "172.20.0.3",
    "IPAddress": "172.18.0.4",
/docker-gen:
    "IPAddress": "172.18.0.3",
/nginx-proxy:
    "IPAddress": "172.20.0.2",
    "IPAddress": "172.18.0.2",
3
Drakes

Inspect hat bei mir nicht funktioniert. Vielleicht als ich -net Host und einige Namespaces verwendet habe.

Wie auch immer, ich fand das gut:

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

Ich musste die IP-Adresse des Docker-Containers nach dem Namen des Docker-Containers extrahieren, um sie in Bereitstellungsskripten weiter verwenden zu können. Zu diesem Zweck habe ich den folgenden Bash-Befehl geschrieben:

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\}'

Angenommen, es könnte praktisch sein, es in ein Bash-Skript einzufügen, das my_container_name als Argument erwartet ...

3

Verwenden Sie diesen Alias ​​zusammen mit der akzeptierten Antwort, wenn Sie einen bestimmten praktischen Alias ​​benötigen, um eine bestimmte Container-IP zu erhalten

alias dockerip='f(){ docker inspect $1|grep -i "ipaddress.*[12]*\.[0-9]*"|sed -e "s/^  *//g" -e "s/[\",]//g" -e "s/[*,]//g" -e "s/[a-zA-Z: ]//g" | sort --unique;  unset -f f; }; f'

und dann kannst du deine container ip mit bekommen

dockerip <containername>  

Sie können auch containerid anstelle von containername verwenden

Übrigens akzeptierte großartige Antworten führen nicht zu einer sauberen Ausgabe, daher habe ich sie bearbeitet und so verwendet.

alias dockerips='for NAME in $(docker ps --format {{.Names}}); do echo -n "$NAME:"; docker inspect $NAME|grep -i "ipaddress.*[12]*\.[0-9]*"|sed -e "s/^  *//g" -e "s/[\",]//g" -e "s/[_=*,]//g" -e "s/[a-zA-Z: ]//g "| sort --unique;done'
2

Dieses Skript erhält die IPv4-Adresse für alle laufenden Container, ohne die Ergebnisse weiter zu verarbeiten oder zu interpretieren. Wenn Sie den Containernamen auch nicht möchten, können Sie einfach die Zeile "echo -n $ NAME:" entfernen. Ideal für die Automatisierung oder das Befüllen von Variablen.

#!/bin/sh
for NAME in $(docker ps --format {{.Names}})
do
  echo -n "$NAME:"
  docker inspect $NAME | grep -i "ip.*[12]*\.[0-9]*" | \
         sed -e 's/^  *//g' -e 's/[",]//g' -e 's/[a-zA-Z: ]//g'
done

sie können auch einfach einen Alias ​​erstellen, wenn Sie dies möchten:

alias dockerip='for NAME in $(docker ps --format {{.Names}}); do echo -n "$NAME:"; docker inspect $NAME|grep -i "ip.*[12]*\.[0-9]*"|sed -e "s/^  *//g" -e "s/[*,]//g" -e "s/[a-zA-Z: ]//g"'

Wenn Sie schnell alle Docker-IP-Adressen anzeigen möchten oder den Instanznamen nicht eingeben möchten, können Sie den Befehl docker ps hacken und Folgendes zu Ihrer ~/.bashrc -Datei hinzufügen:

function docker-ips() {
    docker ps | while read line; do
        if `echo $line | grep -q 'CONTAINER ID'`; then
            echo -e "IP ADDRESS\t$line"
        else
            CID=$(echo $line | awk '{print $1}');
            IP=$(docker inspect -f "{{ .NetworkSettings.IPAddress }}" $CID);
            printf "${IP}\t${line}\n"
        fi
    done;
}

Dies geht aus einem Vorschlag von Andrew Johnstone am Docker GitHub hervor: https://github.com/docker/docker/issues/8786

1
Nicolas Zozol
docker inspect --format "{{ .NetworkSettings.Networks.mynetwork.IPAddress }}" <containername or containerID here>

Das obige gilt für Windows-Container, bei denen ein Netzwerk mit einem eingerichtet wurde

docker create network mynetwork 
1
Boris

Versuchen Sie es in Windows PowerShell:

     docker inspect -f "{{ .NetworkSettings.Networks.nat.IPAddress }}" <container id>

Die akzeptierte Antwort deckt genau das ab, was ziemlich gut zu tippen ist, aber hier ist eine kleine Verbesserung:

docker container inspect \
  --format '{{range .NetworkSettings.Networks}}{{.IPAddress}} {{end}}' \
  $container_id_or_name

Dabei wird der docker container inspect anstelle des allgemeineren docker inspect verwendet, da der Docker in seinen Befehlen zu einer Substantiv- + Verbsyntax wechselt und die Mehrdeutigkeit der zu untersuchenden Objekte beseitigt. Ich habe auch ein Leerzeichen nach der IP-Adresse eingefügt, da Container sich in mehr als einem Docking-Netzwerk mit mehr als einer IP-Adresse befinden können. Das könnte gegen jedes andere Zeichen oder jeden anderen String ausgetauscht werden, der für Sie Sinn ergibt.


Für diejenigen, die wissen möchten, wie sie nach anderen Werten suchen können, verwende ich häufig Folgendes, um eine vom Docker formatierte Syntax in json auszugeben:

docker container inspect --format '{{json .}}' $container_id_or_name | jq .

Möglicherweise müssen Sie jq installieren, damit dies funktioniert, oder Sie können den nachfolgenden Befehl weglassen, um den json als einzelne lange Zeile zu lesen. Wenn Sie diese Ausgabe anzeigen, können Sie jeden Schlüsselnamen und seine Eltern sehen, sodass Sie Ihre eigenen Formatzeichenfolgen erstellen können, um alles auszugeben, was Sie möchten. Die Formatsyntax wird mit Golangs Vorlage mit einigen zusätzliche Docker-spezifische Funktionen enthalten implementiert.


Grundsätzlich möchte ich, sobald Docker den Container erstellt hat, meine eigenen Skripte für die Codebereitstellung und die Containerkonfiguration erstellen.

Der Hauptgrund für meine Antwort ist, dass dieser Kommentar eine große rote Fahne für mich hat. Es zeigt an, dass Ihre Bilder nicht alles enthalten, was zum Ausführen Ihrer Anwendung erforderlich ist. Dies ist ein großes Anti-Pattern beim Arbeiten mit Containern. Mit einem Dutzend Kunden über viele Jahre hinweg habe ich noch keinen realen Anwendungsfall gefunden, um eine direkte Verbindung zu einem Container über dessen interne IP-Adresse vom Docker-Host herzustellen, für den es keine bessere Option gab. Wenn sich in Ihrem Container eine Konfiguration nach dem Start befindet, die ausgeführt werden muss, wird dies häufig mit einem Entypoint-Skript durchgeführt.

Es gibt auch eine rote Flagge, mit der Sie das Netzwerkmodell des Dockers umgehen. Beim Docker-Netzwerk gibt es zwei Möglichkeiten. Erstens geschieht dies bei der Kommunikation zwischen Containern mit einem vom Benutzer erstellten Netzwerk und unter Verwendung des integrierten DNS von Docker, um eine Verbindung zum Container über den Namen oder den Netzwerkalias herzustellen, anstatt über eine IP-Adresse, die sich ändern würde, wenn der Container neu erstellt wird. Für die Kommunikation von außerhalb des Dockers mit dem Container wird dazu ein Port vom Docker-Host auf den Container veröffentlicht und dann eine Verbindung zum Host über diesen Port und nicht direkt zum Container hergestellt. Wenn Sie sich an diese beiden Optionen halten, sollten Sie auf Ihre Anwendung zugreifen können, ohne die interne IP-Adresse zu kennen.

1
BMitch

Überprüfen Sie dieses Skript: https://github.com/jakubthedeveloper/DockerIps

Es gibt Containernamen mit ihren IPs im folgenden Format zurück:

abc_nginx 172.21.0.4
abc_php 172.21.0.5
abc_phpmyadmin 172.21.0.3
abc_mysql 172.21.0.2
0
JakubK

das hat bei mir geklappt, ich laufe auf docker-toolbox 18.09.3, bei windows 10 home edition:

tippe den Befehl 'docker-machine ls'

λ docker-machine ls NAME ACTIVE DRIVER STATE URL SWARM DOCKER-FEHLER default * virtualbox Läuft unter tcp: //192.168.98.100: 2376 v18.09.6

es würde die tatsächliche IP unter der URL-Spalte anzeigen. Z.B. "192.168.98.100"

0
gWay