[Zaktualizowano1] Mam powłokę, która zmieni parametry jądra TCP w niektórych funkcjach, ale teraz muszę uruchomić tę powłokę w kontenerze Dockera, co oznacza, że ​​powłoka musi wiedzieć, że działa w kontenerze i przestać konfigurować jądro.

Teraz nie jestem pewien, jak to osiągnąć, oto zawartość /proc/self/cgroupwnętrza pojemnika:

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

Jakiekolwiek flagi powyżej, których mogę użyć, aby dowiedzieć się, czy ten proces działa w kontenerze?

[Zaktualizowano2]: Zauważyłem również, że ustalanie, czy proces działa w lxc / Docker , ale wydaje się nie działać w tym przypadku, zawartość /proc/1/cgroupmojego kontenera to:

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

No / lxc / containerid

Aby sprawdzić wewnątrz kontenera Docker, czy jesteś w kontenerze Docker, czy nie, można to zrobić za pomocą /proc/1/cgroup. Jak sugeruje ten post , możesz wykonać następujące czynności:

Poza kontenerem docker wszystkie wpisy /proc/1/cgroupkończą się, /jak widać tutaj:

vagrant@ubuntu-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:/

Wewnątrz kontenera Docker niektóre grupy kontrolne będą należeć do Dockera (lub LXC):

vagrant@ubuntu-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:/

Docker tworzy .dockerenvi .dockerinit( usunięte w wersji 1.11 ) pliki na górze drzewa katalogów kontenera, więc możesz chcieć sprawdzić, czy one istnieją.

Coś takiego powinno działać.

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

Używamy harmonogramu proc (/ proc / $ PID / schedule), aby wyodrębnić PID procesu. PID procesu wewnątrz kontenera będzie się różnił od jego PID na hoście (system niekontenerowy).

Na przykład wynik polecenia / proc / 1 / schedule w kontenerze zwróci:

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

Na hoście innym niż kontener:

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

Pomaga to w rozróżnieniu, czy jesteś w kontenerze, czy nie. np. możesz zrobić:

if [[ ! $(cat /proc/1/sched | head -n 1 | grep init) ]]; then {
    echo in docker
} else {
    echo not in docker
} fi

Rozwiązanie Thomasa jako kod:

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

Uwaga

readZe zmienną manekina jest proste idiom za to się wyświetli niczego? . Jest to kompaktowa metoda przekształcania być może rozwlekłego greplub awkw test wzoru.

Dodatkowa uwaga dotycząca czytania

W moim przypadku działa sprawdzanie numeru i-węzła „/”. Wewnątrz dockera jest bardzo dużo. Poza dokerem jest to bardzo niska liczba, np. „2”. Sądzę, że to podejście zależałoby również od używanego systemu plików.

Przykład

Wewnątrz dokera:

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

Poza dokerem

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

W skrypcie:

#!/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

Musieliśmy wykluczyć procesy działające w kontenerach, ale zamiast sprawdzać tylko grupy cgroup Dockera, zdecydowaliśmy się porównać /proc/<pid>/ns/pidz systemem init pod adresem /proc/1/ns/pid. Przykład:

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

Lub w naszym przypadku chcieliśmy mieć jedną wkładkę, która generuje błąd, jeśli proces NIE jest w pojemniku

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

który możemy wykonać z innego procesu i jeśli kod zakończenia ma wartość zero, to określony PID działa w innej przestrzeni nazw.

Na podstawie komentarza Dana Walsha o używaniu SELinux ps -eZ | grep container_t, ale bez konieczności psinstalacji:

$ podman run --rm fedora:31 cat /proc/1/attr/current
system_u:system_r:container_t:s0:c56,c299
$ podman run --rm alpine cat /proc/1/attr/current
system_u:system_r:container_t:s0:c558,c813
$ docker run --rm fedora:31 cat /proc/1/attr/current
system_u:system_r:container_t:s0:c8,c583
$ cat /proc/1/attr/current
system_u:system_r:init_t:s0

To właśnie mówi ci używasz w w pojemniku, ale nie które Runtime.

Nie sprawdzono innych środowisk wykonawczych kontenera, ale https://opensource.com/article/18/2/understanding-selinux-labels-container-runtimes zawiera więcej informacji i sugeruje, że jest to powszechnie używane, może również działać w przypadku rkt i lxc?

Stworzyłem mały skrypt w Pythonie. Mam nadzieję, że ktoś uzna to za przydatne. :-)

#!/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)