Inspeccionando un contenedor docker

En este post, aprenderemos a utilizar el comando docker container inspect. Resumiré cómo comprobar la IP del contenedor docker, el puerto, el nombre, el estado, la ruta interna, la capacidad, los logs y la red.

1. Comando Verificar Contenedor Docker

Hay dos comandos que puedes utilizar para comprobar la información general de un contenedor Docker.

1.1. Comando `inspect' para información detallada

El primer comando es el comando inspect para ver los detalles de un contenedor. Puedes usarlo así para obtener los detalles de uno o más contenedores en formato JSON.

$ docker container inspect [OPTIONS] CONTAINER [CONTAINER...]

Si escribes el comando directamente, obtendrás un montón de cosas por las que desplazarte. Éstas son las más importantes

[
    {
        "id": "72256fae4d38ad302a4788771e0155b03c315a8389fe4327af3912d9e2ae0415",
        "Created": "2023-05-27T01:32:38.177055001Z",
        "Path": "/docker-entrypoint.sh",
        "Args": [
            "nginx",
            "-g",
            "daemon off;"
        ],
        "State": {
        "Status": "running",
        "Running": true,
        "Paused": false,
        ...
        "Pid": 3403,
        "ExitCode": 0,
        "Error": "",
        "StartedAt": "2023-05-27T01:32:38.380814543Z",
        "FinishedAt": "0001-01-01T00:00:00Z"        },
        "Image": "sha256:c42efe0b54387756e68d167a437aef21451f63eebd9330bb555367d67128386c",
        "Name": "/pedantic_cray",
        "ResolvConfPath": "/var/lib/docker/containers/72256fae4d38ad302a4788771e0155b03c315a8389fe4327af3912d9e2ae0415/resolv.conf"
        ,        "HostnamePath": "/var/lib/docker/containers/72256fae4d38ad302a4788771e0155b03c315a8389fe4327af3912d9e2ae0415/hostname",
        "HostsPath": "/var/lib/docker/containers/72256fae4d38ad302a4788771e0155b03c315a8389fe4327af3912d9e2ae0415/hosts",
        ...
        "HostConfig": {},
        "GraphDriver": {},
        "Mount": [],
        "Config": {},
        "NetworkSettings": {}
    }
]

Los elementos Id y Name son el ID único y el nombre del contenedor, y los elementos Path y Args son los archivos o comandos ejecutados cuando se crea el contenedor, La entrada State indica el estado actual del contenedor. Los elementos ResolveConfPath, HostnamePath, HostsPath, y HostConfig contienen rutas de archivos o sentencias de configuración que configuran el entorno del host Docker, Los elementos Image, NetworkSettings y GraphDriver muestran la imagen del contenedor, la red y el entorno de almacenamiento.

Debido a que el comando inspect de Docker está diseñado para mostrar todo sobre un contenedor, puede ser abrumador usarlo cuando quieres ver información específica. Por esta razón, proporciona la opción --format, que te permite utilizar el paquete `text/template' del lenguaje Go para mostrar sólo la información que deseas.

1.2. Usando plantillas Go para la opción --format

Debido a que Docker está escrito en el lenguaje Go, que es excelente para controlar la concurrencia, notarás algunos préstamos de la sintaxis Go. La opción --format del comando inspect es uno de esos ejemplos de préstamos de sintaxis Go.

Abajo hay un ejemplo simple de un text/template en Go, pero no intentes entenderlo, sólo míralo. La parte clave es la línea t, _ = t.Parse("Nombre: {.Nombre} }, Edad: {.Edad} }\n"). Puedes ver que la plantilla Go obtiene cada propiedad de la estructura Persona con dos llaves y un único punto.

package main
 
import (
    "os"
    "text/template"
)
 
type Person struct {
    Name string
    Age  int
}
 
func main() {
    t := template.New("person template")
 
    t, _ = t.Parse("Name: { {.Name} }, Age: { {.Age} }\n")
    p := Person{Name: "Alice", Age: 30}
 
    t.Execute(os.Stdout, p)
}
 

Docker utiliza la misma sintaxis. Puedes configurar una plantilla pensando en el archivo JSON de salida como una gran estructura, y cada campo como una propiedad de esa estructura.

Por ejemplo, vamos a imprimir el registro Status del contenedor. El elemento Status está dentro del campo de nivel superior State. Así que podríamos escribir algo como esto

$ docker container inspect --format='{ {.State.Status} }' CONTAINER

devolverá el siguiente resultado

$ docker container inspect --format='{ {.State.Status} }' 7225
running

Como puedes ver, puedes personalizar la salida usando la sintaxis de plantillas Go.

Para personalizar la salida, consulta la página Formatting commands and log output (opens in a new tab) en la documentación oficial de Docker. Está explicado de forma intuitiva, por lo que deberías ser capaz de entenderlo enseguida.

1.3. El comando stats para comprobar la información en tiempo real

El comando stats muestra la CPU, el uso de memoria y el número de procesos de todos los contenedores en ejecución en tiempo real, así como la E/S acumulada a través de la red o la interfaz de bloques.

Para utilizarlo, escribe el siguiente comando

$ docker container stats [OPTIONS] [CONTAINER...]

Accederás a otra pantalla que muestra información en tiempo real, como se muestra a continuación.

CONTAINER ID   NAME            CPU %  ...
72256fae4d38   pedantic_cray   0.00%  ...

Si sólo desea imprimir la información actual y no la que se actualiza en tiempo real, añada la opción --no-stream. Verás que el prompt vuelve después de imprimir la información.

Ahora vamos a ver cómo imprimir información específica basada en estos dos comandos a su vez.

2. Obtener el nombre y el estado

Puedes imprimir el nombre y el estado de un contenedor usando el comando ls y el comando inspect. El primero expresa tiempo relativo y el segundo tiempo absoluto, por lo que puedes elegir uno u otro en función de tus necesidades.

2.1. ls muestra el tiempo relativo

Hay varias formas de obtener el nombre y el estado de un contenedor. La primera es el comando docker container ls (--all), que ya hemos visto en Ejecutar un contenedor y Detener/Salir de un contenedor.

Como se muestra a continuación, puedes obtener una lista simple de los nombres y estados de los contenedores. Basta con mirar la entrada STATUS y la entrada NAMES.

$ docker container ls
CONTAINER ID   ...   STATUS       NAMES
72256fae4d38   ...   Up 5 hours   pedantic_cray

El comando ls también puede tomar la opción --format, sobre la que aprendimos en la Sección 1.2. A continuación se muestra un comando que sólo muestra el nombre del contenedor y el estado como una lista.

$ docker container ls --format='table { {.Names} }\t{ {.Status} }'
NAMES           STATUS
pedantic_cray   Up 6 hours

Las palabras clave table y \t son comandos que dan salida como una tabla. Ver Sección 1.2 .

2.2. inspeccionar para obtener tiempos absolutos

Si el comando 1ls1 da salida a tiempos relativos como se muestra arriba, se puede usar el comando inspect para dar salida al estado exacto, nombre, hora de creación, hora de inicio, etc. de un único contenedor.

$ docker container inspect --format ' Container name: { {println .Name}} } State: { {println .State.Status} } Created at: { {println .Created}} } Started at: { { {println .State.StartedAt}} }' 7225
Container name: /pedantic_cray
State: running
Created at: 2023-05-27T01:32:38.177055001Z
Started at: 2023-05-27T01:32:38.380814543Z

La palabra clave println añade un salto de línea después de la entrada actual.

3. Comprobar IP, Puerto

3.1. Comprobación de la IP del contenedor

Para comprobar la IP del contenedor se utiliza el comando inspect.

docker container inspect --format='{ {range $network, $config := .NetworkSettings.Networks} }[{ {$network} }]: { {println $config.IP Address} }{ {end} }' 7225
[bridge]: 172.17.0.2

La palabra clave range y la palabra clave { {end} } actúan como un bucle en la plantilla Go. Como los contenedores Docker tienen múltiples direcciones IP dependiendo de la red a la que estén conectados, usamos la palabra clave range para imprimirlas todas. La IP por defecto se puede encontrar comprobando la entrada IPAddress de la red, normalmente llamada bridge.

3.2. Comprobación de puertos de contenedor

Se proporciona el comando para comprobar los puertos de los contenedores, por lo que puede comprobarlos fácilmente de la siguiente manera.

$ docker container port 7225
80/tcp -> 0.0.0.0:8000

Como se muestra en Sección 3.1, puedes producir la misma salida usando el comando inspect y una plantilla Go. Pruébalo si tienes tiempo.

4. Comprobando la ruta dentro del contenedor

Hay dos formas de comprobar la ruta dentro de un contenedor: desde fuera del contenedor y desde dentro del contenedor.

4.1. Comprobación de la ruta interna desde fuera del contenedor

El comando docker container exec proporciona una forma de emitir el comando deseado al shell del contenedor desde fuera del contenedor.

Por ejemplo, el siguiente comando imprimirá la ruta al directorio de trabajo del contenedor actual.

$ docker container exec 7225 pwd
/

También puedes navegar por los archivos y directorios que desees.

$ docker container exec -u root 7225 ls /usr/share/nginx/html
50x.html
index.html

Añadiendo la opción -u root se ejecutará el comando con privilegios root.

4.2. Comprobando la ruta interna dentro de un contenedor

Si quieres acceder al interior de un contenedor para ver sus rutas internas, ejecuta la shell del contenedor con la opción -it.

$ docker container exec -it 7225 /bin/sh
# pwd
/
# ls /usr/share/nginx/html
50x.html  index.html
# exit

Como en el último prompt del ejemplo anterior, teclea exit para salir del shell.

5. Comprobación de la capacidad

El comando para comprobar la capacidad total de todos los contenedores en su entorno local es el siguiente

$ docker system df
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          2         2         181.8MB   0B (0%)
Containers      3         1         3.281kB   2.186kB (66%)
Local Volumes   0         0         0B        0B
Build Cache     0         0         0B        0B

Muestra la cantidad de espacio ocupado actualmente por todas las imágenes, contenedores, volúmenes y cachés en el entorno Docker, con la entrada RECLAIMABLE indicando la cantidad de espacio para cada objeto que no está en uso.

6. Comprobación de logs

El comando para comprobar los logs de un contenedor es el siguiente. Si desea comprobar los registros en tiempo real, utilice la opción -f (--follow). Si desea ver sólo los registros recientes y la salida de contenedores antiguos, puede especificar un número con la opción -n (--tail). La opción --since también es útil para imprimir sólo los registros de los últimos 50 s (segundos), 30 m (minutos) y 5 h (horas).

$ docker container logs --since 10h --tail 5 --follow 7225
2023/05/27 01:32:38 [notice] 1#1: start worker processes
2023/05/27 01:32:38 [notice] 1#1: start worker process 29
2023/05/27 01:32:38 [notice] 1#1: start worker process 30
2023/05/27 01:32:38 [notice] 1#1: start worker process 31
2023/05/27 01:32:38 [notice] 1#1: start worker process 32

7. Verificación de la red

El proceso de verificación de la red de un contenedor es el siguiente. Primero, comprueba la lista de redes conectadas al contenedor, y luego comprueba los detalles de estas redes.

El comando para comprobar la lista de redes conectadas a un contenedor

$ docker container inspect --format='{ {range $network, $config := .NetworkSettings.Networks} }{ {println $network}  }{ {end} }' 7225
bridge
db-net

Este comando imprime una lista de nombres de red, como se muestra arriba. Ahora, utilice el comando Nombre de red con de la siguiente manera para ver sus detalles.

$ docker network inspect db-net
[
    {
        "Name": "db-net",
        "Id": "74b2026af3ee7d328aab14d33894d1c9fc31cd21176051c7c90cab1440342ae7",
        ...

Una discusión más detallada de la información de red será cubierta en un futuro post sobre la Red Docker.

8. Reflexiones finales

En este post, hemos aprendido acerca de los comandos de verificación de contenedores Docker. Espero que esto te ayude cuando necesites saber cómo verificar la IP de un contenedor Docker, puerto, nombre, estado, ruta interna, capacidad, registros y red.