Come determinare se un processo viene eseguito all'interno di lxc / Docker?

Esiste un modo per determinare se un processo (script) viene eseguito all'interno di un contenitore lxc (~ Docker runtime)? So che alcuni programmi sono in grado di rilevare se funzionano all'interno di una macchina virtuale, è disponibile qualcosa di simile per lxc / docker?

Il modo più affidabile è verificare /proc/1/cgroup. Essa vi dirà i gruppi di controllo del processo init, e quando si è non è in un contenitore, che sarà /per tutte le gerarchie. Quando ti trovi in un contenitore, vedrai il nome del punto di ancoraggio. Con i contenitori LXC / Docker, sarà qualcosa di simile /lxc/<containerid>o /docker/<containerid>rispettivamente.

Docker crea un .dockerenvfile nella radice dell'albero delle directory all'interno del contenitore. È possibile eseguire questo script per verificare

#!/bin/bash
if [ -f /.dockerenv ]; then
    echo "I'm inside matrix ;(";
else
    echo "I'm living in real world!";
fi

ALTRO: Ubuntu in realtà ha uno script bash: /bin/running-in-containere in realtà può restituire il tipo di contenitore in cui è stato invocato. Potrebbe essere utile. Non so di altre grandi distro però.

Su un nuovo sistema Ubuntu 16.04, nuovo systemd & lxc 2.0

sudo grep -qa container=lxc /proc/1/environ

Un modo conciso per controllare la finestra mobile in uno script bash è:

#!/bin/bash
if grep docker /proc/1/cgroup -qa; then
   echo I'm running on docker.
fi

Comoda funzione Python per verificare se in esecuzione in Docker:

def in_docker():
    """ Returns: True if running in a Docker container, else False """
    with open('/proc/1/cgroup', 'rt') as ifh:
        return 'docker' in ifh.read()

Usiamo il proc proc sched (/ proc / $ PID / sched) per estrarre il PID del processo. Il PID del processo all'interno del contenitore sarà diverso, quindi è PID sull'host (un sistema non contenitore).

Ad esempio, l'output di / proc / 1 / sched su un contenitore restituirà:

root@33044d65037c:~# cat /proc/1/sched | head -n 1
bash (5276, #threads: 1)

In un host non contenitore:

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

Questo aiuta a distinguere se ci si trova in un contenitore o meno.

Il modo più semplice sarebbe controllare l'ambiente. Se hai ilcontainer=lxc variabile, ti trovi in ​​un contenitore.

Altrimenti, se sei root, puoi provare a eseguire mknodo mountoperare, se fallisce, molto probabilmente ti trovi in ​​un contenitore con capacità rilasciate.

La mia risposta vale solo per i processi Node.js ma può essere pertinente per alcuni visitatori che si imbattono in questa domanda alla ricerca di una risposta specifica Node.js.

Ho avuto lo stesso problema e basandomi su /proc/self/cgroupho creato un pacchetto npm esclusivamente per questo scopo, per rilevare se un processo Node.js viene eseguito all'interno di un contenitore Docker o meno.

Il modulo containerizzato npm ti aiuterà in Node.js. Al momento non è testato in Io.js ma potrebbe funzionare anche lì.

Controlla tutte le soluzioni sopra in Python:

import os

def in_container():
    proc_1 = r'/proc/1/sched'

    if os.path.exists(proc_1):
        with open(proc_1, 'r') as fp:
            out = fp.read()
    else:
        out = ''

    checks = [
        'docker' in out,
        '/lxc/' in out,
        out.split(' ')[0] not in ('systemd', 'init',),
        os.path.exists('./dockerenv'),
        os.path.exists('/.dockerinit'),
        os.getenv('container') is not None
    ]
    return any(checks)


if __name__ == '__main__':
    print(in_container())

Verifica teorica:

$ docker run --rm -it --mount type=bind,source=${PWD}/incontainer.py,target=/tmp/script.py python:3 python /tmp/script.py
True

Docker si sta evolvendo di giorno in giorno, quindi non possiamo dire con certezza se rimarranno .dockerenv .dockerinitin futuro.

Nella maggior parte dei gusti Linux initè il primo processo da avviare. Ma nel caso di contenitori questo non è vero.

#!/bin/bash
if ps -p1|grep -q init;then  
  echo "non-docker" 
else 
  echo "docker" 
fi

Domande e risposte SO: "Scopri se il sistema operativo è in esecuzione in un ambiente virtuale" ; sebbene non coincida con la domanda del PO, in effetti risponde a casi comuni di ricerca in quale contenitore ci si trova (se non del tutto).

In particolare, installa e leggi il codice di questo script bash che sembra funzionare abbastanza bene:

virt-what :

sudo apt install virt-what

Ho tradotto la risposta di JJC in rubino

def in_docker
  File.open('/proc/1/cgroup', 'rt') do |f|
    contents = f.read
    return contents =~ /docker/i || contents =~ /kubepod/i
  end
rescue StandardError => e
  p 'Local development'
  p e
  false
end

In un contenitore finestra mobile, le voci /proc/self/cgroupsono montate su cgroups sull'host.

ad es. in un contenitore

# awk -F: '/cpuset/' /proc/self/cgroup
3:cpuset:/docker/22bd0c154fb4e0d1b6c748faf1f1a12116acc21ce287618a115ad2bea41256b3

mentre lo stesso sull'host

$ awk -F: '/cpuset/' /proc/self/cgroup
3:cpuset:/

Usare qualcosa nella shell per un test di basso profilo

is_running_in_container() {
  awk -F: '/cpuset/ && $3 ~ /^\/$/{ c=1 } END { exit c }' /proc/self/cgroup
}

if is_running_in_container; then
  echo "Aye!! I'm in a container"
else 
  echo "Nay!! I'm not in a container"
fi

Forse questo fa il trucco:

if [ -z $(docker ps -q) ]; then
    echo "There is not process currently running"
else
    echo "There are processes running"
fi

È questo che vuoi? Spero che aiuti =)