ver - listar contenedores en docker




¿Cómo obtener la dirección IP de un contenedor Docker desde el host? (20)

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

¿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.


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

docker-ip() {
  docker inspect --format '{{ .NetworkSettings.IPAddress }}' "[email protected]"
}

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}}' "[email protected]"
}

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

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)

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"


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

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

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

Para Windows 10:

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

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'

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

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

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"

Puede utilizar la docker inspect <container id>

Ejemplo:

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

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.

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.


Utilizar:

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

docker inspect CONTAINER_ID | grep "IPAddress"


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.


docker inspect <container id> | grep -i ip

Por ejemplo:

docker inspect 2b0c4b617a8c | grep -i ip






docker