Cómo obtener la dirección IP de un contenedor Docker del host

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

Básicamente, una vez que Docker crea el contenedor, quiero rodar mi propio despliegue de código y scripts de configuración del contenedor.

La --formatopción de inspectviene al rescate.

La sintaxis moderna del cliente Docker es:

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

La sintaxis del antiguo cliente Docker es:

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

Estos comandos devolverán la dirección IP del contenedor Docker.

Como se menciona en los comentarios: si está en Windows, use comillas dobles en "lugar de comillas simples 'alrededor de las llaves.

Puedes usar docker inspect <container id> .

Por ejemplo:

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

Primero obtenga la ID del contenedor:

docker ps

(La primera columna es para ID de contenedor)

Use la ID del contenedor para ejecutar:

docker inspect <container ID>

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

O simplemente hazlo:

docker inspect <container id> | grep "IPAddress"

docker inspect CONTAINER_ID | grep "IPAddress"

Puede agregar -ia grep para ignorar el caso, incluso lo siguiente funcionará:

docker inspect CONTAINER_ID | grep -i "IPaDDreSS"

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-composeel comando será este:

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

El resultado será:

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

Agregue este script de shell en su ~/.bashrcarchivo relevante:

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

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

docker-ip YOUR_CONTAINER_ID

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

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

Mostrar todas las direcciones IP del contenedor:

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

En Docker 1.3+, también puede verificarlo usando:

Ingrese el Docker en ejecución (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

Para ventanas:

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

A partir de Docker versión 1.10.3, compilación 20f81dd

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

docker network inspect bridge

Que luego debería 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"
        }
    }
]

Ejecutar:

docker ps -a

Esto mostrará imágenes activas de la ventana acoplable:

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

Use el valor de ID DE CONTENEDOR:

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

"172.17.0.2"

Basado en algunas de las respuestas que me encantaron, decidí fusionarlas con una función para obtener todas las direcciones IP y otra para un contenedor específico. Ahora están en mi .bashrcarchivo.

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

Contenedores de referencia por nombre:

docker run ... --name pg-master

Luego tome la dirección de la dirección IP por su nombre:

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

Escribí el siguiente script de Bash para obtener una tabla de direcciones IP de todos los contenedores que se ejecutan 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.

Aquí hay una respuesta rápida de trabajo:

Obtenga su nombre de contenedor o ID:

docker container ls

Luego obtenga la IP:

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

Obtén el puerto:

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

Docker está escrito en Go y también usa la sintaxis Go para fines de consulta.

Para inspeccionar la dirección IP de un contenedor en particular, debe ejecutar el comando ( -fpara "formato"):

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

Para la ID o nombre del contenedor, puede ejecutar el comando

docker container ls

que enumerará cada contenedor en ejecución.

Aquí hay una solución que desarrollé hoy en Python, usando el docker inspect container salida JSON como fuente de datos.

Tengo muchos contenedores e infraestructuras que tengo que inspeccionar, y necesito obtener información básica de red de cualquier contenedor, de forma rápida y bonita. . Por eso 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'])

El resultado es:

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

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

Sin embargo, si usa una red puente personalizada o una red superpuesta, encontré que lo siguiente funciona mejor:

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

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

Yo uso esta manera simple

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

p.ej

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

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.

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

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

Salida:

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

¡¡¡NOTA!!! para Docker Compose Usage:

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

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

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

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

Corriendo con --cidfile=filename , Docker volca la ID del contenedor a "nombre de archivo".

Consulte " Docker ejecuta la sección equivalente PID " para obtener más información.

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

Usando un archivo PID:

1. Ejecutando contenedor con --cidfileparámetro, el app.cidcontenido del archivo es como:

   a29ac3b9f8aebf66a1ba5989186bd620ea66f1740e9fe6524351e7ace139b909
   

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

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

3. Puede extraer la IP del contenedor utilizando un script Python en línea:

   $ 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
   

Aquí hay una 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'])

Consulte " 10 alternativas para obtener las direcciones IP del contenedor Docker " para obtener más información.

Para windows 10:

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

Esto enumerará todas las IP del contenedor en el host:

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

Docker inspecciona el uso para imprimir todos los contenedores ips y sus respectivos nombres

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

Solo para completar:

Realmente me gusta la --formatopción, pero al principio no estaba al tanto, así que utilicé un simple Python one-liner para obtener el mismo resultado:

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

Combinando respuestas anteriores con la búsqueda de la ID del contenedor basada en el nombre de la imagen Docker:

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

Utilizar:

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

Para uso de contenedores de Windows

docker exec <container> ipconfig

donde <container>está el nombre o la identificación del contenedor.

Puede usar docker pspara encontrar la identificación del contenedor.

Si olvidó la ID del contenedor o no desea manipular con 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í puede encontrar toda la información sobre el contenedor también IP.