यह जांचने के लिए कि क्या एक प्रक्रिया डॉक कंटेनर के अंदर चल रही है

Question 1

[Updated1] मेरे पास एक शेल है जो कुछ कार्यों में टीसीपी कर्नेल मापदंडों को बदल देगा, लेकिन अब मुझे इस शेल को डॉकटर कंटेनर में चलाने की आवश्यकता है, इसका मतलब है कि शेल को यह जानना होगा कि यह कंटेनर के अंदर चल रहा है और कर्नेल को कॉन्फ़िगर करना बंद कर दें।

अब मुझे यकीन नहीं है कि कैसे हासिल किया जाए, यहाँ /proc/self/cgroupकंटेनर के अंदर की सामग्री है :

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

अगर यह प्रक्रिया कंटेनर के अंदर चल रही है तो क्या मैं ऊपर किसी झंडे का उपयोग कर सकता हूं?

[Updated2]: मैंने यह भी देखा है कि यदि कोई प्रक्रिया lxc / Docker के अंदर चलती है , तो यह निर्धारित करती है , लेकिन ऐसा नहीं लगता है कि इस मामले में, /proc/1/cgroupमेरे कंटेनर की सामग्री इस प्रकार है:

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

नहीं / lxc / कंटेनड

Question 2

एक डॉकटर कंटेनर के अंदर की जाँच करने के लिए यदि आप डॉकटर कंटेनर के अंदर हैं या नहीं /proc/1/cgroup। जैसा कि इस पोस्ट से पता चलता है कि आप निम्नलिखित कर सकते हैं:

एक डॉकटर कंटेनर के बाहर /proc/1/cgroupअंत में सभी प्रविष्टियाँ /जैसा कि आप यहाँ देख सकते हैं:

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:/

डॉकटर कंटेनर के अंदर कुछ नियंत्रण समूह डोकर (या 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:/

Question 3

डॉकटर बनाता है .dockerenvऔर ~~.dockerinit~~( v1.11 में हटा दिया गया ) कंटेनर की निर्देशिका ट्री के शीर्ष पर फाइलें होती हैं ताकि आप जांच सकें कि क्या वे मौजूद हैं।

कुछ इस तरह से काम करना चाहिए।

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

Question 4

कोड के रूप में थॉमस का समाधान:

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

ध्यान दें

readएक डमी चर के साथ के लिए एक सरल मुहावरा है यह क्या किसी भी उत्पादन का उत्पादन? । यह एक संभवतः वर्बोज़ मोड़ के लिए एक कॉम्पैक्ट विधि है grepया awkएक में परीक्षण एक पैटर्न की।

पढ़ने पर अतिरिक्त ध्यान दें

Question 5

हम प्रक्रिया के PID को निकालने के लिए proc की अनुसूची (/ proc / $ PID / अनुसूची) का उपयोग करते हैं। कंटेनर के अंदर प्रक्रिया की पीआईडी अलग होगी फिर यह मेजबान (एक गैर-कंटेनर प्रणाली) पर पीआईडी है।

उदाहरण के लिए, कंटेनर पर / proc / 1 / शेड्यूल का आउटपुट वापस आएगा:

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

जबकि एक गैर-कंटेनर होस्ट पर:

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

यह इस बात में अंतर करने में मदद करता है कि आप कंटेनर में हैं या नहीं। जैसे आप कर सकते हैं:

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

Question 6

मेरे लिए क्या काम करता है '/' के इनकोड नंबर की जांच करना। डॉकटर के अंदर, इसकी बहुत अधिक संख्या है। कर्ता के बाहर, इसकी संख्या बहुत कम है जैसे '2'। मुझे लगता है कि यह दृष्टिकोण भी इस्तेमाल किया जा रहा FileSystem पर निर्भर करेगा।

उदाहरण

कर्ता के अंदर:

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

कर्ता के बाहर

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

एक स्क्रिप्ट में:

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

Question 7

हमें कंटेनरों में चलने वाली प्रक्रियाओं को बाहर करने की जरूरत थी, लेकिन हमने केवल dog cgroups के लिए जाँच करने के बजाय /proc/<pid>/ns/pidinit सिस्टम की तुलना करने का निर्णय लिया /proc/1/ns/pid। उदाहरण:

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

या हमारे मामले में हम एक लाइनर चाहते थे जो एक कंटेनर में प्रक्रिया नहीं होने पर एक त्रुटि उत्पन्न करता है

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

जिसे हम किसी अन्य प्रक्रिया से निष्पादित कर सकते हैं और यदि निकास कोड शून्य है तो निर्दिष्ट PID एक अलग नामस्थान में चल रहा है।

Question 8

SELinux का उपयोग करने के बारे में डैन वॉल्श की टिप्पणी के आधार पर ps -eZ | grep container_t, लेकिन psस्थापित किए जाने की आवश्यकता के बिना :

$ 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

यह सिर्फ आपको बताता है कि आप एक कंटेनर में चल रहे हैं , लेकिन कौन से रनटाइम में नहीं।

अन्य कंटेनर रनटाइम की जाँच नहीं की, लेकिन https://opensource.com/article/18/2/understanding-selinux-labels-container-runtimes अधिक जानकारी प्रदान करता है और यह व्यापक रूप से उपयोग किया जाता है, यह भी rkt और lxc के लिए काम कर सकता है ?

Question 9

मैंने एक छोटी अजगर स्क्रिप्ट बनाई है। आशा है कि कोई इसे उपयोगी पाता है। :-)

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