Comment obtenir un Panneau contenant l'adresse IP 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

docker inspect CONTAINER_ID | grep "IPAddress"

Si vous ajoutez -i à grep, IPAddress boîtier peut être quelque chose comme ce qui suit:

docker inspect CONTAINER_ID | grep -i "IPADDress"

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

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

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

docker-ip YOUR_CONTAINER_ID

Pour la nouvelle version de l'Docker, veuillez utiliser les informations suivantes:

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

Dans le Panneau de 1,3+, vous pouvez également le vérifier par les étapes ci-dessous:

Entrer dans la course Docker (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 windows:

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

Exécuter:

docker ps -a

Cette affiche active docker images:

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 le CONTENEUR de la valeur de l'ID:

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

"172.17.0.2"

De référence des conteneurs par nom:

docker run ... --name pg-master

Puis saisir l'adresse IP de l'adresse par le nom:

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

Docker est faite à l'interne en Go et il utilise Aller syntaxe de l'interrogation trop.

Pour l'inspection sur 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'id de conteneur ou d'un nom, vous pouvez exécuter la commande docker container ls.
Il donnera la liste en bas de chaque course conteneur.

Réponse rapide (Cela fonctionne):

Obtenir votre Nom de conteneur ou ID:

docker container ls

Puis le faire (get IP):

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

Obtenir Port:

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

D'étendre ko-dos " réponse, voici un alias de la liste de tous les conteneur noms 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'

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

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

De sortie:

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

Pour windows 10:

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

Juste pour être complet:

J'aime vraiment le --format option, mais au début, je n'étais pas au courant de cette option, j'ai donc utilisé une 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"]'

Pour ceux qui sont venus de Google pour trouver la solution pour l'exécution d'une commande du terminal (pas par script), jid (interactive JSON forer vers le bas util avec la saisie semi-automatique et suggestion) vous permettent d'obtenir la même chose avec moins de frappe.

docker inspect $CID | jid

Type tab .Net tab et vous verrez suivantes:

[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 suivantes:

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

Pour Windows conteneurs utilisation

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.

Ce sera la liste de tous les conteneur IPs 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 proposé le menu fixe à l'API Python encore. Docker API solution pour obtenir l'Adresse IP est assez simple.

*NIX système d'exploitation basé sur: docker api 3.7 (mis à jour grâce à canadadry d'après les 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 Agnostique: docker api 4.0.x (ajoutée grâce à pds d'après les 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 dur à trouver, mais c'est utile. en outre, cela peut être facilement modifié pour trouver toutes les adresses IP attribuées à un conteneur sur les différents réseaux.

J'ai dû extraire le panneau contenant son Adresse IP par docker nom de conteneur pour une autre utilisation dans des scripts de déploiement.
Pour cet effet, 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\}'

Suppose que cela pourrait être pratique pour le mettre dans un script bash qui pourrait s'attendre my_container_name comme argument...

La accepté de répondre ne fonctionne pas bien avec de multiples réseaux par récipient:

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

Avec la accepté de répondre si vous avez besoin d'un alias pratique pour obtenir un conteneur spécifique ip utiliser 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 nomconteneur

BTW acceptée grande réponse doenst produire un propre de sortie donc j'ai édité et en l'utilisant comme cela ;

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'

Essayer dans Windows PowerShell:

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

La accepté de répondre couvre exactement quel type assez bien, mais ici, c'est une amélioration mineure:

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

Il utilise le docker container inspect au lieu de la plus générique docker inspect depuis le panneau se déplace à un substantif+verbe syntaxe dans leurs commandes, et la suppression de l'ambiguïté de ce que vous inspectez. J'ai aussi inclus un espace après l'adresse IP depuis les conteneurs peuvent être sur plus d'un docker du réseau avec plus d'une adresse IP. Qui pourraient être remplacés par n'importe quel autre caractère ou une chaîne qui fait sens pour vous.

Pour ceux qui veulent savoir comment ils peuvent rechercher d'autres valeurs, j'utilise souvent le suivant à sortir n'importe quel support formaté syntaxe en 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 de côté la fin de commande pour lire le json comme une seule longue ligne. Lors de la visualisation de cette sortie, vous pouvez voir chaque nom de la clé et c'est aux parents de sorte que vous pouvez créer vos propres chaînes de format de sortie que vous voulez. Le format de la syntaxe est mis en œuvre avec golang du modèle avec certains extra docker fonctions spécifiques inclus.

Fondamentalement, une fois le Panneau crée le conteneur, je veux rouler mon propre code de déploiement et de configuration du conteneur de scripts.

La principale raison de ma réponse à ce commentaire, qui a un énorme drapeau rouge pour moi. Il indique que vos images ne contiennent pas tout ce qui est nécessaire pour exécuter votre application, un grand anti-modèle lorsque l'on travaille avec des conteneurs. Avec une douzaine de clients depuis de nombreuses années, je n'ai pas encore trouver une utilisation dans le monde réel de cas de se connecter directement à un conteneur interne adresse IP à partir du panneau d'accueil qui n'ont pas une meilleure option. Au lieu de cela, si il y a de post-configuration de démarrage dans votre conteneur qui doit s'exécuter, cela se fait souvent avec un point d'entrée script.

Il y a aussi un drapeau rouge que vous êtes en contournant le panneau du modèle de mise en réseau. Avec le panneau de réseautage, il y a deux options. Tout d'abord, lors de la communication entre les conteneurs, c'est fait avec un utilisateur a créé un réseau et l'utilisation de docker est intégré dans le système DNS pour se connecter à la boîte par nom ou l'alias de réseau plutôt que par une adresse IP qui allait changer lorsque le conteneur est recréé. Et pour communiquer à partir de l'extérieur de menu fixe pour le conteneur, ce qui est fait par la publication d'un port à partir du panneau d'accueil pour le conteneur, et ensuite la connexion à l'hôte sur le port plutôt que le contenant. Si vous vous en tenez à ces deux options, vous devriez être en mesure d'accéder à votre demande, sans jamais connaître son adresse IP interne.

Vérifier ce script: https://github.com/jakubthedeveloper/DockerIps

Il retourne contenant les noms avec leurs adresses IP dans le 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

À L'Aide De Python Nouveau API:

import docker

client = docker.DockerClient()
container = client.containers.get("NAME")
ip_add = container.attrs['NetworkSettings']['IPAddress']
print(ip_add)

for containerId in $(sudo docker ps -a | cut -f1 -d' ' | grep -v CONTAINER); do
    echo " ContainerId - $containerId >>  $(sudo docker inspect --format '{{ .NetworkSettings.IPAddress }}' $containerId) "
done