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 auprès de l'hôte après la création d'un nouveau conteneur?
En gros, une fois que Docker a créé le conteneur, je souhaite lancer mes propres scripts de déploiement de code et de configuration de conteneur.
L'option --format de inspecter vient à la rescousse.
Syntaxe du client Modern Docker:
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' container_name_or_id
Ancienne syntaxe du client Docker:
docker inspect --format '{{ .NetworkSettings.IPAddress }}' container_name_or_id
Ce qui retournera seulement l'adresse IP.
Comme mentionné dans les commentaires: si vous êtes sur Windows, utilisez des guillemets doubles " au lieu de guillemets simples ' autour des accolades.
Vous pouvez utiliser docker inspect <container id>
Exemple:
CID=$(docker run -d -p 4321 base nc -lk 4321);
docker inspect $CID
D'abord obtenir l'ID du conteneur:
docker ps
(La première colonne est pour l'ID de conteneur)
Utilisez l'ID de conteneur pour exécuter:
docker inspect <container ID>
En bas, sous "NetworkSettings", vous pouvez trouver "IPAddress"
Ou juste faire:
docker inspect <container id> | grep "IPAddress"
docker inspect CONTAINER_ID | grep "IPAddress"
Si vous ajoutez -i à grep, la casse IPAddress peut ressembler à ceci:
docker inspect CONTAINER_ID | grep -i "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 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 de shell dans votre fichier ~/.bashrc ou dans le fichier correspondant:
docker-ip() {
docker inspect --format '{{ .NetworkSettings.IPAddress }}' "$@"
}
Ensuite, pour obtenir l'adresse IP d'un conteneur, procédez comme suit:
docker-ip YOUR_CONTAINER_ID
Pour la nouvelle version du Docker, veuillez utiliser les éléments suivants:
docker-ip() {
docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$@"
}
Afficher tous 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 via les étapes ci-dessous:
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
A partir de la version 1.10.3 de Docker, compilez 20f81dd
Sauf indication contraire de votre part, Docker lance toujours vos conteneurs dans le réseau de ponts. Donc, vous pouvez essayer cette commande ci-dessous:
docker network inspect bridge
Ce qui devrait ensuite renvoyer une section Containers 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 les images actives du menu fixe:
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 CONTAINER ID:
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 en une fonction pour obtenir toutes les adresses IP et une autre pour un conteneur spécifique. Ils sont maintenant dans mon fichier .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 une adresse IP spécifique du conteneur.
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 son 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 s'exécutant 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 remplacer le réseau variable par votre propre nom de réseau.
Docker est créé en interne dans Go et utilise également la syntaxe Go pour les requêtes.
Pour inspecter l'adresse IP d'un conteneur particulier, vous devez exécuter la commande (option -f pour le formatage).
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. Il listera tous les conteneurs en cours d'exécution.
Voici une solution que j'ai développée aujourd'hui en Python, 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 je dois obtenir des informations de base sur le réseau 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 ressemble à 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
Réponse rapide (ça marche):
Obtenez votre nom ou identifiant de conteneur:
docker container ls
Ensuite, faites-le (obtenez l'adresse IP):
docker inspect <container_ID Or container_name> |grep 'IPAddress'
Obtenez le port:
docker inspect <container_ID Or container_name> |grep 'Port'
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.
Toutefois, si vous utilisez un réseau de pont personnalisé ou un réseau superposé, les éléments ci-dessous fonctionnent 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 répertoriant 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 à l'aide de Docker Toolbox, vous pouvez utiliser l'application Kitematic pour obtenir l'adresse IP du conteneur:
- Sélectionnez le conteneur
- Cliquez sur Paramètres
- Cliquez sur l'onglet Ports.
Pour obtenir l'adresse IP et le port hôte d'un conteneur:
docker inspect containerId | awk '/IPAddress/ || /HostPort/'
Sortie:
"HostPort": "4200"
"HostPort": "4200"
"SecondaryIPAddresses": null,
"IPAddress": "172.17.0.2",
"IPAddress": "172.17.0.2",
Pour les fenêtres 10:
docker inspect --format "{{ .NetworkSettings.IPAddress }}" containerId
NOTE !!! pour Docker Compose Usage:
Etant donné que Docker Compose crée un réseau isolé pour chaque cluster, les méthodes ci-dessous ne fonctionnent pas avec docker-compose.
Le moyen le plus élégant et le plus simple 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 les identifiants de conteneur dans un fichier comme les programmes Linux:
En cours d'exécution avec le paramètre --cidfile=filename, Docker sauvegarde l'identifiant du conteneur dans ce fichier.
Docker exécute la section équivalente au PID
--cidfile="app.cid": Write the container ID to the file
Utilisation du fichier PID
- Conteneur en cours d'exécution avec le paramètre
--cidfile, le contenu du fichierapp.cidest comme ci-dessous:
a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909
Vous pouvez utiliser le contenu du fichier pour inspecter les conteneurs Docker:
➜ blog-v4 git:(develop) ✗ docker inspect `cat app.cid`Extraction du conteneur IP en ligne _ scriptPython:
$ 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
Forme plus conviviale
#!/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/
Il existe 10 possibilités pour obtenir les adresses IP du conteneur Docker.
Juste pour être complet:
J'aime beaucoup l'option - format, mais au début, n'étant pas conscient de cette option, j'ai utilisé un simple Python one-liner 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"]'
Combinaison des réponses précédentes avec la recherche de l'ID de conteneur basé sur le nom de l'image Docker.
docker inspect --format '{{ .NetworkSettings.IPAddress }}' `docker ps | grep $IMAGE_NAME | sed 's/\|/ /' | awk '{print $1}'`
Si vous avez oublié l'ID de conteneur ou si vous ne voulez pas manipuler avec des commandes Shell, il est préférable d'utiliser une interface utilisateur telle que Portainer.
$ 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 les conteneurs et les adresses IP.
Docker inspect utilise pour imprimer tous les ips de conteneur et ses noms respectifs
docker ps -q | xargs -n 1 docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}} {{ .Name }}' | sed 's/ \// /'
Pour conteneurs Windows utiliser
docker exec <container> ipconfig
où <container> est le nom ou le id du conteneur.
Vous pouvez utiliser docker ps pour trouver l'id du conteneur.
Utilisation:
docker inspect $CID | grep IPAddress | grep -v null| cut -d '"' -f 4 | head -1
Ceci listera toutes les adresses IP de conteneur sur l'hôte:
Sudo docker ps -aq | while read line; do Sudo docker inspect -f '{{.Name}} - {{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $line ; done
Personne n'a encore proposé l'API Docker Python. La solution API Docker pour obtenir une adresse IP est assez simple.
* OS basé sur NIX: docker api 3.7 (mis à jour grâce à canadadry à partir des commentaires)
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 (ajouté grâce à pds à partir des commentaires)
import docker
client = docker.from_env()
container = client.containers.get(container_name)
vars( container )["attrs"]["NetworkSettings"]["Networks"]["<NETWORK_NAME>"]["IPAddress"]
N'était pas trop difficile à trouver, mais est utile. En outre, cela peut être facilement modifié pour trouver toutes les adresses IP attribuées à un conteneur sur différents réseaux.
Pour ceux qui venaient de Google pour trouver une solution d'exécution de commande à partir d'un terminal (et non par script), jid (utilitaire interactif JSON interactif avec complétion automatique et suggestion) vous permet de réaliser la même chose avec moins de frappe.
docker inspect $CID | jid
Type tab .Net tab et vous verrez ce 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": "",
Type .IPA tab et vous verrez ce qui suit:
[Filter]> .[0].NetworkSettings.IPAddress
"172.17.0.2"
docker inspect <container id> | grep -i ip
Par exemple:
docker inspect 2b0c4b617a8c | grep -i ip
La réponse acceptée ne fonctionne pas bien avec plusieurs réseaux par conteneur:
> docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' cc54d96d63ea
172.20.0.4172.18.0.5
La prochaine meilleure réponse est plus proche:
> docker inspect cc54d96d63ea | grep "IPAddress"
"SecondaryIPAddresses": null,
"IPAddress": "",
"IPAddress": "172.20.0.4",
"IPAddress": "172.18.0.5",
J'aime utiliser jq pour analyser le réseau JSON:
> 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
}
}
Pour lister les adresses IP de chaque conteneur devient alors:
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",
Inspecter n'a pas fonctionné pour moi. Peut-être que j'utilisais -net Host et quelques espaces de noms.
Quoi qu'il en soit, j'ai trouvé que cela fonctionnait bien:
docker exec -i -t NAME /sbin/ifconfig docker0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'
J'ai dû extraire l'adresse IP du conteneur docker par nom de conteneur docker pour une utilisation ultérieure dans les scripts de déploiement. Pour cela, 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 soit pratique de le placer dans un script bash, qui attendrait my_container_name en tant qu’argument ...
Avec la réponse acceptée si vous avez besoin d'un alias spécifique pour obtenir un conteneur IP spécifique, utilisez cet alias.
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'
et alors vous pouvez obtenir votre conteneur IP avec
dockerip <containername>
Vous pouvez également utiliser containerid au lieu de ContainName.
BTW a accepté la bonne réponse ne produisant pas de sortie nette, je l'ai donc modifiée et utilisée comme ceci;
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'
Ce script obtiendra l'adresse IPv4 de tous les conteneurs en cours d'exécution sans traitement supplémentaire ni interprétation des résultats. Si vous ne voulez pas non plus le nom du conteneur, vous pouvez simplement supprimer la ligne "echo -n $ NAME:". Idéal pour l'automatisation ou le remplissage de variables.
#!/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
vous pouvez aussi créer un alias si vous le souhaitez:
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"'
Si vous voulez voir rapidement toutes les adresses IP de Docker, ou sans saisir le nom de l'instance, vous pouvez pirater la commande docker ps en l'ajoutant à votre fichier ~/.bashrc:
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;
}
Cela provient d'une proposition de Andrew Johnstone au Docker GitHub: https://github.com/docker/docker/issues/8786
docker inspect --format "{{ .NetworkSettings.Networks.mynetwork.IPAddress }}" <containername or containerID here>
Ce qui précède s’applique aux conteneurs Windows où un réseau a été configuré avec un
docker create network mynetwork
Essayez dans Windows PowerShell:
docker inspect -f "{{ .NetworkSettings.Networks.nat.IPAddress }}" <container id>
La réponse acceptée couvre exactement ce qu'il faut taper assez bien, mais voici une amélioration mineure:
docker container inspect \
--format '{{range .NetworkSettings.Networks}}{{.IPAddress}} {{end}}' \
$container_id_or_name
Ceci utilise le docker container inspect au lieu du plus générique docker inspect puisque le menu fixe passe à une syntaxe nom + verbe dans leurs commandes et élimine l'ambiguïté de ce que vous inspectez. J'ai également inclus un espace après l'adresse IP, car les conteneurs peuvent se trouver sur plusieurs réseaux Docker avec plusieurs adresses IP. Cela pourrait être échangé contre tout autre caractère ou chaîne qui a du sens pour vous.
Pour ceux qui veulent savoir comment rechercher d'autres valeurs, j'utilise souvent les éléments suivants pour exporter toute syntaxe formatée dans Docker dans json:
docker container inspect --format '{{json .}}' $container_id_or_name | jq .
Vous devrez peut-être installer jq pour que cela fonctionne, ou vous pouvez laisser la commande de fin pour lire le json comme une longue ligne. Lorsque vous affichez cette sortie, vous pouvez voir chaque nom de clé et ses parents afin de créer vos propres chaînes de format pour produire tout ce que vous voulez. La syntaxe de formatage est implémentée avec modèle de golang avec quelques fonctions supplémentaires spécifiques au menu fixe incluses .
En gros, une fois que Docker a créé le conteneur, je souhaite lancer mes propres scripts de déploiement de code et de configuration de conteneur.
La principale raison de ma réponse est que ce commentaire a un énorme drapeau rouge pour moi. Cela indique que vos images ne contiennent pas tout ce dont vous avez besoin pour exécuter votre application, ce qui est un gros anti-motif lorsque vous travaillez avec des conteneurs. Avec une douzaine de clients répartis sur de nombreuses années, je n'ai pas encore trouvé de cas d'utilisation réel permettant de se connecter directement à un conteneur grâce à son adresse IP interne issue de l'hôte docker, qui n'avait pas la meilleure option. Au lieu de cela, s'il existe une configuration post-démarrage dans votre conteneur qui doit être exécutée, cela se fait souvent avec un script de point d'entrée.
Il y a également un drapeau rouge indiquant que vous contournez le modèle de réseau de docker. Avec le réseau de docker, il y a deux options. Premièrement, lors de la communication entre des conteneurs, ceci est effectué avec un réseau créé par l'utilisateur et en utilisant le DNS intégré de docker pour se connecter au conteneur par son nom ou son alias réseau plutôt que par une adresse IP qui serait modifiée lors de la recréation du conteneur. Et pour communiquer de l'extérieur du menu fixe vers le conteneur, cela se fait en publiant un port de l'hôte du menu fixe vers le conteneur, puis en se connectant à l'hôte sur ce port plutôt que directement au conteneur. Si vous vous en tenez à ces deux options, vous devriez pouvoir accéder à votre application sans même connaître son adresse IP interne.
Vérifiez ce script: https://github.com/jakubthedeveloper/DockerIps
Il renvoie les noms de conteneur avec leurs adresses IP au format suivant:
abc_nginx 172.21.0.4
abc_php 172.21.0.5
abc_phpmyadmin 172.21.0.3
abc_mysql 172.21.0.2
cela a fonctionné pour moi, je cours sur docker-toolbox 18.09.3, sous windows 10 home edition:
tapez la commande 'docker-machine ls'
λ docker-machine ls NOM URL DE L'ETAT DU CONDUCTEUR ACTIVE ERREURS DE DOCKER SWARM default * virtualbox En cours d'exécution tcp: //192.168.98.100: 2376 v18.09.6
il montrerait l'adresse IP réelle dans la colonne URL. Par exemple. '192.168.98.100'