Comment obtenir l'adresse IP d'un conteneur Docker auprès de l'hôte

Existe-t-il une commande que je peux exécuter pour obtenir l'adresse IP du conteneur directement à partir de l'hôte après la création d'un nouveau conteneur?

Fondamentalement, une fois que Docker crée le conteneur, je souhaite lancer mes propres scripts de déploiement de code et de configuration de conteneur.

L' --formatoption de inspectvient à la rescousse.

La syntaxe du client Docker moderne est:

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

L'ancienne syntaxe du client Docker est:

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

Ces commandes renverront l'adresse IP du conteneur Docker.

Comme mentionné dans les commentaires: si vous êtes sous Windows, utilisez des guillemets doubles "au lieu de guillemets simples 'autour des accolades.

Vous pouvez utiliser docker inspect <container id>.

Par exemple:

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

Obtenez d'abord l'ID du conteneur:

docker ps

(La première colonne est pour l'ID du conteneur)

Utilisez l'ID de conteneur pour exécuter:

docker inspect <container ID>

En bas, sous "NetworkSettings", vous pouvez trouver "IPAddress"

Ou faites simplement:

docker inspect <container id> | grep "IPAddress"

docker inspect CONTAINER_ID | grep "IPAddress"

Vous pouvez ajouter -ià grep pour ignorer le cas, puis même ce qui suit fonctionnera:

docker inspect CONTAINER_ID | grep -i "IPaDDreSS"

Pour obtenir tous les noms de conteneurs et leurs adresses IP en une seule commande.

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

Si vous utilisez docker-composela commande sera la suivante:

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 ~/.bashrcfichier ou dans le fichier correspondant:

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

Ensuite, pour obtenir une adresse IP d'un conteneur, faites simplement 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 du conteneur:

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

Dans Docker 1.3+, vous pouvez également le vérifier en utilisant:

Entrez le Docker en cours d'exécution (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

Pour les fenêtres:

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

Depuis Docker version 1.10.3, build 20f81dd

Sauf indication contraire de Docker, Docker lance toujours vos conteneurs dans le réseau de pont. Vous pouvez donc essayer cette commande ci-dessous:

docker network inspect bridge

Qui devrait ensuite renvoyer une section Conteneurs qui affichera l'adresse IP de ce conteneur en cours d'exécution.

[
    {
        "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 actives:

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

Utilisez la valeur ID CONTENEUR:

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

"172.17.0.2"

Sur la base de certaines des réponses que j'ai adorées, 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 .bashrcdossier.

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

Saisissez ensuite l'adresse IP par son nom:

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

J'ai écrit le script Bash suivant pour obtenir un tableau des adresses IP de tous les conteneurs fonctionnant 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 le réseau variable en votre propre nom de réseau.

Voici une réponse de travail rapide:

Obtenez le nom ou l'ID de votre conteneur:

docker container ls

Obtenez ensuite l'IP:

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

Obtenez le port:

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

Docker est écrit en Go et utilise également la syntaxe Go à des fins de requête.

Pour inspecter l'adresse IP d'un conteneur particulier, vous devez exécuter la commande ( -fpour "format"):

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

Pour l'ID ou le nom du conteneur, vous pouvez exécuter la commande

docker container ls

qui répertorie tous les conteneurs en cours d'exécution.

Voici une solution que j'ai développée aujourd'hui en Python, en utilisant la docker inspect containersortie JSON 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, de manière rapide et jolie . C'est pourquoi j'ai fait ce script.

IMPORTANT: depuis la version 1.9, Docker vous permet de créer plusieurs réseaux et de les attacher 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:

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

Ce qui précède 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é que ce qui suit fonctionne mieux:

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

Pour étendre la réponse de ko-dos, voici un alias pour répertorier tous les noms de conteneurs 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'

J'utilise ce moyen simple

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

par exemple

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

Si vous avez installé Docker à l'aide de Docker Toolbox, vous pouvez utiliser l'application Kitematic pour obtenir l'adresse IP du conteneur:

1. Sélectionnez le conteneur
2. Cliquez sur Paramètres
3. Cliquez sur l'onglet Ports.

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

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

Production:

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

REMARQUE!!! pour Docker Compose Usage:

Étant donné que Docker Compose crée un réseau isolé pour chaque cluster, les méthodes ci-dessous ne fonctionnent pas avec docker-compose.

La manière la plus élégante et la plus simple est de définir une fonction shell, actuellement la réponse la plus votée chez WouterD :

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

Docker peut écrire des ID de conteneur dans un fichier comme les programmes Linux:

En cours d'exécution avec --cidfile=filename, Docker vide l'ID du conteneur dans "nom de fichier".

Voir « Docker exécute la section équivalente PID » pour plus d'informations.

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

Utilisation d'un fichier PID:

1. Conteneur en cours d'exécution avec --cidfileparamètre, le app.cidcontenu du fichier est comme:

   a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909
   

2. Vous pouvez utiliser le contenu des fichiers pour inspecter les conteneurs Docker:

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

3. Vous pouvez extraire l'IP du conteneur à l'aide d'un script Python en ligne:

   $ 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
   

Voici une forme plus conviviale pour l'homme:

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

Voir « 10 alternatives pour obtenir les adresses IP du conteneur Docker » pour plus d'informations.

Pour Windows 10:

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

Cela répertoriera toutes les adresses IP des conteneurs sur l'hôte:

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

Docker inspecte l'utilisation pour imprimer tous les ips du conteneur et ses noms respectifs

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

Juste pour être complet:

J'aime vraiment l' --formatoption, mais au début, je n'en étais pas conscient, j'ai donc utilisé un simple doublure 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"]'

Combiner les réponses précédentes avec la recherche de l'ID de conteneur en fonction du nom de l'image Docker:

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

Utilisation:

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

Pour les conteneurs Windows, utilisez

docker exec <container> ipconfig

où <container>est le nom ou l' identifiant du conteneur.

Vous pouvez utiliser docker pspour trouver l'id du conteneur.

Si vous avez oublié l'ID du conteneur ou que vous ne souhaitez 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

Vous y trouverez toutes les informations sur le conteneur également IP.