[Updated1] Tôi có một trình bao sẽ thay đổi các tham số hạt nhân TCP trong một số chức năng, nhưng bây giờ tôi cần làm cho trình bao này chạy trong vùng chứa Docker, điều đó có nghĩa là, trình bao cần biết nó đang chạy bên trong một vùng chứa và dừng cấu hình hạt nhân.

Bây giờ tôi không chắc làm thế nào để đạt được điều đó, đây là nội dung /proc/self/cgroupbên trong vùng chứa:

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

Tôi có thể sử dụng bất kỳ cờ nào ở trên để tìm hiểu xem quá trình này có đang chạy bên trong vùng chứa không?

[Updated2]: Tôi cũng đã nhận thấy Xác định xem một quy trình có chạy bên trong lxc / Docker hay không , nhưng có vẻ như nó không hoạt động trong trường hợp này, nội dung trong /proc/1/cgroupvùng chứa của tôi là:

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

Không / lxc / containernerid

Để kiểm tra bên trong vùng chứa Docker xem bạn có đang ở trong vùng chứa Docker hay không, bạn có thể thực hiện thông qua /proc/1/cgroup. Như bài đăng này gợi ý bạn có thể làm như sau:

Bên ngoài thùng chứa docker, tất cả các mục nhập /proc/1/cgroupcuối cùng /như bạn có thể thấy ở đây:

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

Bên trong vùng chứa Docker, một số nhóm điều khiển sẽ thuộc về Docker (hoặc 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 tạo .dockerenvvà .dockerinit( loại bỏ trong v1.11 ) các tệp ở đầu cây thư mục của vùng chứa, vì vậy bạn có thể muốn kiểm tra xem chúng có tồn tại hay không.

Một cái gì đó như thế này sẽ hoạt động.

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

Thomas 'giải pháp dưới dạng mã:

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

Ghi chú

Với readmột biến giả là một thành ngữ đơn giản cho Điều này có tạo ra bất kỳ đầu ra nào không? . Đó là một phương pháp nhỏ gọn để biến một câu có thể dài dòng grephoặc awkthành một bài kiểm tra của một mẫu.

Ghi chú bổ sung khi đọc

Chúng tôi sử dụng lịch trình của proc (/ proc / $ PID / Schedule) để trích xuất PID của quá trình. PID của tiến trình bên trong vùng chứa sẽ khác với PID trên máy chủ (hệ thống không chứa).

Ví dụ: đầu ra của / proc / 1 / Schedule trên vùng chứa sẽ trả về:

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

Khi ở trên máy chủ không chứa:

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

Điều này giúp phân biệt bạn có đang ở trong một thùng chứa hay không. ví dụ bạn có thể làm:

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

Điều hiệu quả với tôi là kiểm tra số inode của '/.' Bên trong docker, một con số rất cao. Bên ngoài docker, nó là một con số rất thấp như '2'. Tôi nghĩ rằng cách tiếp cận này cũng sẽ phụ thuộc vào FileSystem đang được sử dụng.

Thí dụ

Bên trong docker:

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

Bên ngoài docker

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

Trong một tập lệnh:

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

Chúng tôi cần loại trừ các quy trình đang chạy trong vùng chứa, nhưng thay vì chỉ kiểm tra các nhóm docker, chúng tôi quyết định so sánh /proc/<pid>/ns/pidvới hệ thống init tại /proc/1/ns/pid. Thí dụ:

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

Hoặc trong trường hợp của chúng tôi, chúng tôi muốn một lớp lót tạo ra lỗi nếu quy trình KHÔNG nằm trong vùng chứa

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

mà chúng tôi có thể thực thi từ một quy trình khác và nếu mã thoát bằng 0 thì PID được chỉ định đang chạy trong một không gian tên khác.

Dựa trên nhận xét của Dan Walsh về việc sử dụng SELinux ps -eZ | grep container_t, nhưng không yêu cầu pscài đặt:

$ 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

Điều này chỉ cho bạn biết bạn đang chạy trong một vùng chứa, nhưng không phải là thời gian chạy nào.

Không kiểm tra các thời gian chạy vùng chứa khác nhưng https://opensource.com/article/18/2/und hieu-selinux-labels- container-runtimes cung cấp thêm thông tin và cho thấy điều này được sử dụng rộng rãi, cũng có thể hoạt động cho rkt và lxc?

Tôi đã tạo một tập lệnh python nhỏ. Hy vọng ai đó thấy nó hữu ích. :-)

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