Comment obtenir l'adresse IP d'un conteneur Docker de l'hôte?

vous pouvez utiliser docker inspect <container id>

exemple:

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

obtenir D'abord le numéro d'identification du conteneur:

docker ps

(la première colonne correspond au numéro d'identification du conteneur)

utiliser le numéro d'identification du conteneur pour exécuter:

docker inspect <container ID>

en bas, sous "NetworkSettings", vous trouverez "IPAddress "

Ou tout Simplement faire:

docker inspect <container id> | grep "IPAddress"

docker inspect CONTAINER_ID | grep "IPAddress"

pour obtenir tous les noms de conteneur et leurs adresses IP en une seule commande.

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

Si vous utilisez docker-compose la commande sera:

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

la sortie sera:

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

ajoutez ce script shell dans votre ~/.bashrc ou fichier correspondant:

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

alors, pour obtenir une adresse IP d'un conteneur, il suffit de faire ceci:

docker-ip YOUR_CONTAINER_ID

pour la nouvelle version du Docker, veuillez utiliser ce qui suit:

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

afficher toutes les adresses IP des conteneurs:

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

dans Docker 1.3+, vous pouvez également le vérifier par les étapes ci-dessous:

entrez le docker courant:

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

de Docker version 1.10.3, construire 20f81dd

sauf si vous avez dit à Docker le contraire, Docker lance toujours vos conteneurs dans le réseau de ponts. Vous pouvez donc essayer cette commande ci-dessous:

docker network inspect bridge

qui devrait alors retourner une section de conteneurs qui affichera l'adresse IP de ce conteneur courant.

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

Exécuter:

docker ps -a

cela affichera des images de docker actif:

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

utiliser la valeur D'identification du conteneur:

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

"172.17.0.2 "

basé sur certaines des réponses que j'ai aimé, j'ai décidé de les fusionner à une fonction pour obtenir toutes les adresses IP et une autre pour un conteneur spécifique. Ils sont maintenant dans mon dossier .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}}' "$@"
}

la première commande donne l'adresse IP de tous les conteneurs et la seconde l'adresse IP d'un conteneur spécifique.

docker-ips
docker-ip YOUR_CONTAINER_ID

conteneurs de référence par nom:

docker run ... --name pg-master

puis saisissez l'adresse IP par nom:

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

j'ai écrit le script Bash suivant pour obtenir une table d'adresses IP de tous les conteneurs tournant sous 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
}

vous devez changer la variable network à votre propre nom de réseau.

Docker est fait en interne dans Go et il utilise la syntaxe Go pour des buts de requête aussi.

pour inspecter l'adresse IP d'un conteneur particulier, vous devez exécuter la commande(-f pour l'option format)

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

pour l'identification ou le nom du conteneur, vous pouvez exécuter la commande docker container ls . Il dressera la liste de tous les conteneurs en circulation.

Voici une solution que j'ai développée aujourd'hui en Python, en utilisant la sortie JSON" Docker inspect container " comme source de données.

j'ai beaucoup de conteneurs et d'infrastructures que je dois inspecter, et j'ai besoin d'obtenir des informations réseau de base à partir de n'importe quel conteneur, d'une manière rapide et jolie . C'est pourquoi j'ai fait ce script.

IMPORTANT: depuis la version 1.9, Docker vous permet de créez plusieurs réseaux et fixez-les aux conteneurs.

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

la sortie est juste comme ceci:

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

la commande ci-dessus fonctionne si le conteneur est déployé sur le réseau de pont par défaut.

cependant, si vous utilisez un réseau de pont personnalisé ou un réseau de superposition, j'ai trouvé le ci-dessous pour mieux fonctionner:

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

pour étendre la réponse de ko-dos, voici un alias pour lister tous les noms de conteneur et leurs adresses 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'

si vous avez installé Docker en utilisant la boîte à outils Docker, vous pouvez utiliser L'application Kitematic pour obtenir l'adresse IP du conteneur:

1. sélectionner le conteneur
2. cliquez sur Paramètres
3. cliquez dans L'onglet Ports.

NOTE!!! pour Docker composer Usage:

puisque Docker Compose crée un réseau isolé pour chaque cluster, les méthodes ci-dessous ne fonctionne pas avec docker-compose .

le moyen le plus élégant et le plus facile est de définir une fonction shell comme la réponse la plus votée @Wouterd's :

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

Docker peut écrire contenant les id dans un fichier comme les programmes Linux:

avec le paramètre --cidfile=filename , Docker renvoie l'ID du conteneur à ce fichier.

Docker s'exécute PID équivalent de la Section

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

utilisant le fichier PID

1. contenant courant avec --cidfile paramètre, app.cid le contenu du fichier est comme ci-dessous:

a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909

2. Vous pouvez utiliser des fichiers de contenu à inspecter les conteneurs Docker:

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

3. Extraire le Conteneur IP inline script 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

Une Forme Plus Humaine

#!/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/

ici il y a 10 alternatives pour obtenir les adresses IP du conteneur Docker.

Pour windows 10:

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

Juste pour être complet:

j'aime vraiment l'option --format , mais au début je n'étais pas au courant de cette option, donc j'ai utilisé un simple Python pour obtenir le même résultat:

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

pour obtenir l'adresse IP et le port hôte d'un conteneur:

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

sortie:

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

combinant les réponses précédentes avec la recherche du conteneur id basé sur le nom de l'image Docker.

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

pour ceux qui sont venus de Google pour trouver une solution pour l'exécution de commande à partir du terminal (pas par script), jid (un outil interactif JSON drill down Util avec autocomplete et suggestion) vous permet d'atteindre la même chose avec moins de Dactylographie.

docker inspect $CID | jid

Type onglet .Net onglet et vous verrez qui suit:

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

.IPA tab et vous verrez

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

utiliser:

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

Pour Windows conteneurs utiliser

docker exec <container> ipconfig

où <container> est le nom ou la id du conteneur.

Vous pouvez utiliser docker ps pour trouver l'id du conteneur.

si vous avez oublié l'identifiant du conteneur ou si vous ne voulez pas manipuler avec les commandes shell, il est préférable d'utiliser L'interface utilisateur comme 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à vous pouvez trouver toutes les informations sur conteneur aussi IP.

inspection n'a pas fonctionné pour moi. Peut-être que j'utilisais -net host et quelques espaces de noms.

de toute façon, j'ai trouvé que ça marchait bien:

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

j'ai dû extraire l'adresse IP du conteneur docker par le nom du conteneur docker pour une utilisation ultérieure dans les scripts de déploiement. Pour ce faire, j'ai écrit la commande bash suivante:

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

supposons qu'il puisse être pratique de le placer dans un script bash, qui attendrait my_container_name comme argument...

docker inspect <container id> | grep -i ip

par exemple:

docker inspect 2b0c4b617a8c | grep -i ip