los - ¿Cómo obtener la dirección IP de un contenedor Docker desde el host?

docker toolbox windows ip

Question

¿Hay algún comando que pueda ejecutar para obtener la dirección IP del contenedor directamente desde el host después de crear un nuevo contenedor?

Básicamente, una vez que Docker crea el contenedor, quiero rodar mis propios scripts de implementación de código y configuración de contenedor.

Answer 1

A partir de la versión 1.10.3 de Docker, compile 20f81dd

A menos que le dijera a Docker lo contrario, Docker siempre lanza sus contenedores en la red del puente. Así que puedes probar este comando a continuación:

docker network inspect bridge

Que luego debe devolver una sección de Contenedores que mostrará la dirección IP para ese contenedor en ejecución.

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

Answer 2

Agregue este script de shell en su ~/.bashrc o archivo relevante:

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

Luego, para obtener una dirección IP de un contenedor, simplemente haga esto:

docker-ip YOUR_CONTAINER_ID

Para la nueva versión de Docker, use lo siguiente:

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

Answer 3

Basándome en algunas de las respuestas que me encantaron, decidí combinarlas con una función para obtener todas las direcciones IP y otra para un contenedor específico. Ahora están en mi archivo .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}}'' "$@"
}

El primer comando proporciona la dirección IP de todos los contenedores y el segundo la dirección IP de un contenedor específico.

docker-ips
docker-ip YOUR_CONTAINER_ID

Answer 4

Combinando respuestas anteriores con la búsqueda de la identificación del contenedor basada en el nombre de la imagen de Docker.

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

Answer 5

Contenedores de referencia por nombre:

docker run ... --name pg-master

Luego toma la dirección IP por nombre:

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

Answer 6

Docker se realiza internamente en Go y utiliza la sintaxis de Go para fines de consulta también.

Para inspeccionar la dirección IP de un contenedor en particular, debe ejecutar el comando (-f para la opción de formato)

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

Para la identificación o el nombre del contenedor, puede ejecutar el comando docker container ls . Se mostrará una lista de cada contenedor en ejecución.

Answer 7

Ejecutar:

docker ps -a

Esto mostrará imágenes de docker activas:

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

Utilice el valor de ID DEL CONTENEDOR:

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

"172.17.0.2"

Answer 8

En Docker 1.3+, también puede verificarlo a través de los pasos a continuación:

Introduzca el Docker en ejecución:

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

Answer 9

Escribí la siguiente secuencia de comandos Bash para obtener una tabla de direcciones IP de todos los contenedores que se ejecutan en 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
}

Debe cambiar la red variable a su propio nombre de red.

Answer 10

Esta es una solución que desarrollé hoy en Python, utilizando la salida JSON del "contenedor de inspección de la ventana acoplable" como fuente de datos.

Tengo muchos contenedores e infraestructuras que debo inspeccionar, y necesito obtener información básica de la red de cualquier contenedor, de una manera rápida y bonita . Es por eso que hice este guión.

IMPORTANTE: Desde la versión 1.9, Docker le permite crear múltiples redes y adjuntarlas a los contenedores.

#!/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 salida es así:

$ 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

Answer 11

Inspeccionar no funcionó para mí. Tal vez ya estaba usando -net host y algunos espacios de nombres.

De todos modos, encontré esto para trabajar muy bien:

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

Answer 12

Mostrar todas las direcciones IP de los contenedores:

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

Answer 13

Para Windows 10:

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

Answer 14

Para ampliar la respuesta de ko-dos, aquí hay un alias para enumerar todos los nombres de los contenedores y sus direcciones 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''

Answer 15

Para aquellos que vinieron de Google para encontrar una solución para la ejecución de comandos desde el terminal (no por script), jid (un jid interactivo de JSON con autocompletar y sugerir) le permite lograr lo mismo con menos escritura.

docker inspect $CID | jid

Escriba tab .Net tab y verá lo siguiente:

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

Escriba la pestaña .IPA y verá lo siguiente:

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

Answer 16

Para obtener la dirección IP y el puerto de host de un contenedor:

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

Salida:

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

Answer 17

Para obtener todos los nombres de contenedores y sus direcciones IP en un solo comando.

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

Si está utilizando docker-compose el comando será este:

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

La salida será:

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

Answer 18

Para uso de contenedores de Windows

docker exec <container> ipconfig

donde <container> es el nombre o el id del contenedor.

Puede usar la docker ps para encontrar el id del contenedor.

Answer 19

Primero obtenga la identificación del contenedor:

docker ps

(La primera columna es para la identificación del contenedor)

Utilice el ID del contenedor para ejecutar:

docker inspect <container ID>

En la parte inferior, debajo de "Configuración de red", puede encontrar "Dirección de IP"

O simplemente haz:

docker inspect <container id> | grep "IPAddress"

Answer 20

Puede utilizar la docker inspect <container id>

Ejemplo:

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

Answer 21

Sólo para estar completo:

Realmente me gusta la opción --format , pero al principio no era consciente de esa opción, así que usé una línea de Python simple para obtener el mismo resultado:

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

Answer 22

Si instaló Docker usando Docker Toolbox, puede usar la aplicación Kitematic para obtener la dirección IP del contenedor:

1. Selecciona el contenedor
2. Haga clic en Configuración
3. Haga clic en la pestaña Puertos.

Answer 23

Si olvidó el ID del contenedor o no quiere manipularlo con los comandos de shell, es mejor usar la interfaz de usuario como 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

Allí podrás encontrar toda la información sobre el contenedor también de IP.

Answer 24

Tuve que extraer la dirección IP del contenedor de la ventana acoplable por el nombre del contenedor de la ventana acoplable para su uso posterior en los scripts de implementación. Para este propósito he escrito el siguiente comando de bash:

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

Supongamos que podría ser útil colocarlo en un script de bash, que esperaría a my_container_name como un argumento ...

Answer 25

Utilizar:

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

Answer 26

docker inspect CONTAINER_ID | grep "IPAddress"

Answer 27

¡¡¡NOTA!!! para Docker Componer Uso:

Dado que Docker Compose crea una red aislada para cada clúster, los métodos a continuación no funcionan con docker-compose .

La forma más elegante y fácil es definir una función de shell como la respuesta más votada en @WouterD''s :

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

Docker puede escribir identificadores de contenedor en un archivo como los programas de Linux:

Al ejecutarse con el parámetro --cidfile=filename , Docker vuelca el ID del contenedor a este archivo.

Docker ejecuta la sección equivalente PID

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

Usando archivo PID

1. El contenedor de ejecución con el parámetro --cidfile , el contenido del archivo app.cid es como a continuación:

a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909

2. Puede usar el contenido del archivo para inspeccionar los contenedores Docker:

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

3. Extracción del script de Python en línea del contenedor IP:

   $ 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

Forma más amigable para los humanos

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

Aquí hay 10 alternativas para obtener las direcciones IP del contenedor Docker.

Answer 28

La opción --format de inspeccionar viene al rescate.

Sintaxis del cliente Docker moderno:

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

Sintaxis del antiguo cliente Docker:

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

Que devolverá sólo la dirección IP.

Answer 29

docker inspect <container id> | grep -i ip

Por ejemplo:

docker inspect 2b0c4b617a8c | grep -i ip

Answer 30

docker inspect --format ''{{ .NetworkSettings.IPAddress }}'' <containername or containerID here>

Lo anterior funciona si el contenedor se implementa en la red de puente predeterminada.

Sin embargo, si utilizo una red puente personalizada o una red de superposición, encontré que lo siguiente funciona mejor:

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