Como determinar se um processo é executado no lxc / Docker?

Existe alguma maneira de determinar se um processo (script) é executado dentro de um contêiner lxc (~ Docker runtime)? Eu sei que alguns programas são capazes de detectar se são executados dentro de uma máquina virtual. Existe algo semelhante disponível para o lxc / docker?

A maneira mais confiável é verificar /proc/1/cgroup. Ele informará os grupos de controle do processo init e, quando você não estiver em um contêiner, será /para todas as hierarquias. Quando você estiver dentro de um contêiner, verá o nome do ponto de ancoragem. Com os contêineres LXC / Docker, será algo parecido /lxc/<containerid>ou /docker/<containerid>respectivamente.

O Docker cria um .dockerenvarquivo na raiz da árvore de diretórios dentro do contêiner. Você pode executar este script para verificar

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

MAIS: O Ubuntu realmente possui um script bash: /bin/running-in-containere na verdade pode retornar o tipo de contêiner em que foi chamado. Pode ser útil. Porém, não conheço outras distros importantes.

Em um novo sistema ubuntu 16.04, o novo systemd & lxc 2.0

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

Uma maneira concisa de verificar a janela de encaixe em um script bash é:

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

Função útil do Python para verificar se está sendo executado no 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()

Usamos a programação do proc (/ proc / $ PID / sched) para extrair o PID do processo. O PID do processo dentro do contêiner será diferente do PID no host (um sistema sem contêiner).

Por exemplo, a saída de / proc / 1 / sched em um contêiner retornará:

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

Enquanto estiver em um host sem contêiner:

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

Isso ajuda a diferenciar se você está em um contêiner ou não.

A maneira mais fácil seria verificar o ambiente. Se você tiver a container=lxcvariável, você está dentro de um contêiner.

Caso contrário, se você for root, poderá tentar executar mknodou mountoperar, se falhar, provavelmente estará em um contêiner com recursos descartados.

Minha resposta se aplica apenas aos processos do Node.js., mas pode ser relevante para alguns visitantes que se deparam com essa pergunta à procura de uma resposta específica ao Node.js.

Eu tive o mesmo problema e, contando com a /proc/self/cgroupcriação, criei um pacote npm apenas para esse fim - para detectar se um processo Node.js é executado dentro de um contêiner do Docker ou não.

o módulo npm em contêiner ajudará você no Node.js. No momento, ele não está testado no Io.js, mas também pode funcionar lá.

Verifique todas as soluções acima em 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())

Prova de conceito:

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

O Docker está evoluindo dia a dia, então não podemos dizer com certeza se eles continuarão .dockerenv .dockerinitno futuro.

Na maioria dos sabores do Linux, inité o primeiro processo a ser iniciado. Mas no caso de contêineres isso não é verdade.

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

Este SO Q&A: "Descubra se o sistema operacional está sendo executado em um ambiente virtual" ; embora não seja o mesmo que a pergunta do OP, ele realmente responde a casos comuns de encontrar em qual container você está (se é que está).

Em particular, instale e leia o código desse script bash, que parece funcionar muito bem:

virt-what :

sudo apt install virt-what

Traduzi a resposta de JJC para ruby

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

Em um contêiner de janela de encaixe, as entradas /proc/self/cgroupsão montadas em cgroups no host.

por exemplo, em um recipiente

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

enquanto o mesmo no host

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

Usando algo no shell para um teste de baixo perfil

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

Talvez isso faça o truque:

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

É isso que você quer? Espero que ajude =)