[Updated1] tengo un shell que va a cambiar TCP parámetros del kernel en algunas funciones, pero ahora tengo que hacer este shell ejecutar en la ventana acoplable contenedor, que significa, el shell que debe saber es que se ejecuta dentro de un recipiente y dejar de configuración del kernel.

Ahora no estoy seguro de cómo lograr que, de aquí es el contenido de /proc/self/cgroup en el interior del contenedor:

9:hugetlb:/
8:perf_event:/
7:blkio:/
6:freezer:/
5:devices:/
4:memory:/
3:cpuacct:/
2:cpu:/docker/25ef774c390558ad8c4e9a8590b6a1956231aae404d6a7aba4dde320ff569b8b
1:cpuset:/

Cualquier banderas de arriba se puede utilizar para averiguar si este proceso se ejecuta dentro de un contenedor?

[Updated2]: también he notado Determinar si un proceso se ejecuta dentro de lxc/ventana acoplable, pero parece que no funciona en este caso, el contenido en /proc/1/cgroup de mi contenedor es:

8:perf_event:/
7:blkio:/
6:freezer:/
5:devices:/
4:memory:/
3:cpuacct:/
2:cpu:/docker/25ef774c390558ad8c4e9a8590b6a1956231aae404d6a7aba4dde320ff569b8b
1:cpuset:/

No /lxc/containerid

  • No es muy clara la pregunta. ¿Por qué necesita esta?
  • Duplicado de stackoverflow.com/questions/20010199/…
  • no /lxc/<containerid> en mi caso, ver la actualización
  • los parámetros del kernel es de sólo lectura en la ventana acoplable contenedor,así que necesito saber si mi concha se está ejecutando en el interior de contenedores y desactivar las funciones de núcleo en mi concha. ver la actualización.
  • Algunos de los pasos en la secuencia de comandos de intentar modificar los parámetros del kernel, y debe omitirse cuando se ejecuta en la ventana acoplable. Claro.
InformationsquelleAutor harryz | 2014-05-07

7 Comentarios

  1. 52

    A comprobar dentro de un contenedor Docker si está dentro de un contenedor Docker o no se puede hacer a través de /proc/1/cgroup. Como este post sugiere que puede a la siguiente:

    Fuera de una ventana acoplable contenedor de todas las entradas en /proc/1/cgroup final en / como se puede ver aquí:

    [email protected]-13:~$ cat /proc/1/cgroup
    11:name=systemd:/
    10:hugetlb:/
    9:perf_event:/
    8:blkio:/
    7:freezer:/
    6:devices:/
    5:memory:/
    4:cpuacct:/
    3:cpu:/
    2:cpuset:/

    Dentro de una ventana acoplable contenedor de algunos de los grupos de control le pertenecen a la ventana acoplable (o LXC):

    [email protected]-13:~$ docker run busybox cat /proc/1/cgroup
    11:name=systemd:/
    10:hugetlb:/
    9:perf_event:/
    8:blkio:/
    7:freezer:/
    6:devices:/docker/3601745b3bd54d9780436faa5f0e4f72bb46231663bb99a6bb892764917832c2
    5:memory:/
    4:cpuacct:/
    3:cpu:/docker/3601745b3bd54d9780436faa5f0e4f72bb46231663bb99a6bb892764917832c2
    2:cpuset:/
    • la respuesta es más limpio
    • no es estrictamente cierto que «Fuera de una ventana acoplable contenedor de todas las entradas en /proc/1/cgroup final en /». En ubuntu 16.04 por ejemplo tengo: 12:perf_event:/ 11:blkio:/init.scope 10:cpuset:/ 9:devices:/init.scope 8:hugetlb:/ 7:cpu,cpuacct:/init.scope 6:net_cls,net_prio:/ 5:memory:/init.scope 4:pids:/init.scope 3:rdma:/ 2:freezer:/ 1:name=systemd:/init.scope
  2. 81

    Ventana acoplable crea .dockerenv y .dockerinit (eliminado en v1.11) archivos en la parte superior del contenedor del directorio del árbol de modo que usted puede ser que desee comprobar si los hay.

    Algo como esto debería funcionar.

    #!/bin/bash
    if [ -f /.dockerenv ]; then
        echo "I'm inside matrix ;(";
    else
        echo "I'm living in real world!";
    fi
    • Me gusta este, gracias.
    • A menos que, por supuesto, usted o alguien más ha creado /.dockerinit en tu host (quizás por accidente), en cuyo caso será mal fuera de un contenedor.
    • Si alguien más lo hizo en /, a continuación, que son root y tienes el peor de los problemas que a saber si estás en la ventana acoplable o no.
    • .dockerinit ha sido eliminado en las versiones más recientes de la ventana acoplable.
    • Sólo he encontrado /.dockerenv allí.
    • Esto no parece relevante más en la ventana acoplable 1.12, que yo no tengo .dockerinit o .dockerinit
    • Cuidado con confiar en /.dockerenv en el largo plazo. Es no debe ser utilizado de esta manera.
    • También no funciona en la ventana acoplable de Windows.
    • Cualquier solución para hacer esto?

  3. 19

    Utilizamos el proc de sched (/proc/$PID/sched) para extraer el PID del proceso. El proceso del PID en el interior del contenedor se diferencian entonces es el PID en el host (un no-sistema de contenedor).

    Por ejemplo, la salida de /proc/1/sched en un contenedor
    regresará:

    [email protected]:~# cat /proc/1/sched | head -n 1
    bash (5276, #threads: 1)

    Mientras que en un no-contenedor de host:

    $ cat /proc/1/sched  | head -n 1
    init (1, #threads: 1)

    Esto ayuda a diferenciar si está en un recipiente o no. por ejemplo, usted puede hacer:

    if [[ ! $(cat /proc/1/sched | head -n 1 | grep init) ]]; then {
        echo in docker
    } else {
        echo not in docker
    } fi
    • He hecho la respuesta más legible
    • ¿Por qué tener abajo votado ? Solicitud de estado de una razón.
    • esto es en realidad bastante información valiosa. gracias
    • Dependiendo del sistema operativo, «init» puede ser que necesite ser reemplazado con «systemd». Más información sobre systemd aquí.
    • Como se ha mencionado por @BrianV, esto no funciona para mí también.
    • En una ventana acoplable contenedor que se ejecuta en un k8s clúster, head -n1 /proc/1/sched devuelve dumb-init (1, #threads: 1), así que la comprobación se sugiere en esta respuesta se produce un error. (También, contrario a lo que la respuesta sugiere, el PID se muestra como «1» en esa línea aunque estoy haciendo esto en un recipiente).

  4. 16

    Thomas solución de código:

    running_in_docker() {
      (awk -F/ '$2 == "docker"' /proc/self/cgroup | read non_empty_input)
    }

    Nota

    La read con una variable ficticia es una simple frase hecha para eso le produce ninguna salida?. Es un compacto método para convertir una posiblemente detallado grep o awk en un prueba de un patrón.

    Nota adicional en la lectura

    • Excepto…este va a fallar en algunos envrionments, porque, por ejemplo, 3:cpu,cpuacct:/system.slice/docker-1ce79a0dec4a2084d54acf187a1e177e0339dc90d0218b48b4456576ecaf291e.scope no coinciden. Más sencillo grep -q docker /proc/1/cgroup; el código de resultado de que también debe ser suficiente.
    • read podría funcionar para bash, pero en la mayoría de los utilizados dash shell tienes que utilizar read dummy (o similar) o el uso de una construcción como [ -n "$(command)" ]
    • Buena captura, Daniel. Voy a actualizar el texto.
    • Previamente, este afirmó que cualquier Bourne shell compatible apoya la llanura read sin nombre de la variable. Esto sólo es cierto para bash y ksh93. El Opengroup sólo especifica read var y no menciona read comportamiento sin al menos una variable. En bash y ksh93, si no var es dada, leída utiliza la variable de shell REPLY.
    • Esto se soluciona de la solución: (awk-F: ‘$3 ~ /ventana acoplable/’ /proc/self/cgroup | leer non_empty_input)
    • ¿Por qué no podemos simplemente usar awk -F: '$3 ~ /docker/' /proc/self/cgroup | read? A mí me funciona.

  5. 1

    Necesitábamos para excluir a los procesos que se ejecutan en los contenedores, pero en lugar de comprobar sólo para ventana acoplable cgroups decidimos comparar /proc/<pid>/ns/pid para el inicio del sistema en /proc/1/ns/pid. Ejemplo:

    pid=$(ps ax | grep "[r]edis-server \*:6379" | awk '{print $1}')
    if [ $(readlink "/proc/$pid/ns/pid") == $(readlink /proc/1/ns/pid) ]; then
       echo "pid $pid is the same namespace as init system"
    else
       echo "pid $pid is in a different namespace as init system"
    fi

    O en nuestro caso queríamos una funda que genera un error si el proceso NO está en un contenedor

    bash -c "test -h /proc/4129/ns/pid && test $(readlink /proc/4129/ns/pid) != $(readlink /proc/1/ns/pid)"

    que podemos ejecutar desde otro proceso y si el código de salida es cero, entonces el PID especificado se ejecuta en un espacio de nombres diferente.

    • No funciona para mí. Desde dentro de un k8s-programado ventana acoplable contenedor, readlink /proc/self/ns/pid y readlink /proc/1/ns/pid producir la misma salida.
    • Posible que desee probar el uso de github.com/jessfraz/amicontained para ver qué funciones están activadas en el contenedor en tiempo de ejecución.
  6. 1

    Lo que funciona para mí es comprobar que el número de inodo de la ‘/.’
    Dentro de la ventana acoplable, es un número muy alto.
    Fuera de la ventana acoplable, un número muy bajo como ‘2’.
    Creo que este enfoque sería también dependen del sistema de archivos que se utiliza.

    Ejemplo

    Dentro de la ventana acoplable:

    # ls -ali /| sed '2!d' |awk {'print $1'}
    1565265

    Fuera de la ventana acoplable

    $ ls -ali / | sed '2!d' |awk {'print $1'}
    2

    En una secuencia de comandos:

    #!/bin/bash
    INODE_NUM=`ls -ali /| sed '2!d' |awk {'print $1'}`
    if [ $INODE_NUM == '2' ];
    then
            echo "Outside the docker"
    else
            echo "Inside the docker"
    fi
  7. -1

    He creado un pequeño script en python. Espero que alguien la encuentre útil. 🙂

    #!/usr/bin/env python3
    #@author Jorge III Altamirano Astorga 2018
    import re
    import math
    
    total = None
    meminfo = open('/proc/meminfo', 'r')
    for line in meminfo:
        line = line.strip()
        if "MemTotal:" in line:
            line = re.sub("[^0-9]*", "", line)
            total = int(line)
    meminfo.close()
    print("Total memory: %d kB"%total)
    
    procinfo = open('/proc/self/cgroup', 'r')
    for line in procinfo: 
        line = line.strip()
        if re.match('.{1,5}:name=systemd:', line):
            dockerd = "/sys/fs/cgroup/memory" + \
                re.sub("^.{1,5}:name=systemd:", "", line) + \
                "/memory.stat"
            #print(dockerd)
            memstat = open(dockerd, 'r')
            for memline in memstat:
                memline = memline.strip()
                if re.match("hierarchical_memory_limit", memline):
                    memline = re.sub("[^0-9]*", \
                        "", memline)  
                    total = math.floor(int(memline) / 2**10)
            memstat.close()
    procinfo.close()
    print("Total available memory to the container: %d kB"%total)
    • es genial, pero cómo ayuda a determinar si está dentro de un contenedor o no?

Dejar respuesta

Please enter your comment!
Please enter your name here