Docker Rootless რეჟიმი

ყოვლისმომცველი გზამკვლევი Docker-ის დემონისა და კონტეინერების გაშვების შესახებ არაპრივილეგირებული მომხმარებლის სახით, უსაფრთხოების და იზოლაციის გასაუმჯობესებლად

შესავალი Docker Rootless რეჟიმში

Docker-ის Rootless რეჟიმი წარმოადგენს კონტეინერების უსაფრთხოების მნიშვნელოვან გაუმჯობესებას, რადგან ის საშუალებას აძლევს Docker-ის დემონსაც და კონტეინერებსაც იმუშაონ root პრივილეგიების გარეშე. ეს მიდგომა პასუხობს კონტეინერიზაციის ერთ-ერთ ყველაზე მუდმივ უსაფრთხოების გამოწვევას:

Rootless Mode Architecture

- **შემცირებული შეტევის ზედაპირი**: ზღუდავს კონტეინერიდან გასვლის მოწყვლადობების გავლენას
- **მრავალფენიანი დაცვა**: ამატებს დამატებით უსაფრთხოების ფენას კონტეინერის იზოლაციის მიღმა
- **უმცირესი პრივილეგიის პრინციპი**: პროცესები მუშაობენ მხოლოდ მინიმალურად აუცილებელი ნებართვებით
- **რეგულაციურ შესაბამისობასთან მიახლოება**: ეხმარება უსაფრთხოების მოთხოვნების დაკმაყოფილებაში რეგულირებულ გარემოებში
- **მულტითენანტ უსაფრთხოება**: აძლევს შესაძლებლობას კონტეინერების უფრო უსაფრთხო გამოყენებას გაზიარებულ გარემოებში
  1. User namespace remapping: Maps container root (UID 0) to an unprivileged user ID ეს ამომწურავი გზამკვლევი განიხილავს არქიტექტურას, დანერგვას, შეზღუდვებსა და საუკეთესო პრაქტიკებს Docker-ის rootless რეჟიმში გაშვებისათვის, რაც დაგეხმარებათ კონტეინერების უსაფრთხოების გამყარებაში ძირითადი ფუნქციონალის დაკარგვის გარეშე.
  2. Nested namespaces: Creates user, mount, network, and other namespaces without privileges

    Rootless რეჟიმის არქიტექტურა

  3. Rootless networking: Implements user-space networking without root privileges

    უსაფრთხოების მოდელი

    Docker-ის Rootless რეჟიმი ახლებურად წარმოაჩენს Docker-ის ტრადიციულ უსაფრთხოების მოდელს: რუთზე დაფუძნებული გაშვება იცვლება არაპრივილეგირებული მომხმარებლის სახელთა სივრცეებით:
    1. **მომხმარებლის სახელთა სივრცის გადამაპინგება**: კონტეინერის root (UID 0) თავსებადდება არაპრივილეგირებულ მომხმარებლის ID-ზე
    2. **არაპრივილეგირებული დემონი**: Docker-ის დემონი მუშაობს ჩვეულებრივი მომხმარებლის სახელით
    3. **ჩანაცვლებული (nested) სახელთა სივრცეები**: ქმნის user, mount, network და სხვა სახელთა სივრცეებს პრივილეგიების გარეშე
    4. **არაპრივილეგირებული პორტები**: იყენებს ალტერნატიულ პორტების გადამისამართების მექანიზმებს პრივილეგიებზე ქვემოთ მდგომი პორტებისთვის
    5. **Rootless ქსელვა**: ახორციელებს user-space ქსელურებას root-ის პრივილეგიების გარეშე
┌───────────────────────────────────────────┐
│ Host System                               │
│  ┌──────────────────────────────────────┐ │
│  │ User Session (e.g. UID 1000)         │ │
│  │  ┌────────────────────────────────┐  │ │
│  │  │ dockerd (Rootless)             │  │ │
│  │  │                                │  │ │
│  │  │  ┌──────────────────────────┐  │  │ │
│  │  │  │ Container (UID 0 -> 1000)│  │  │ │
│  │  │  └──────────────────────────┘  │  │ │
│  │  └────────────────────────────────┘  │ │
│  └──────────────────────────────────────┘ │
└───────────────────────────────────────────┘

კომპონენტების ცვლილებები

Rootless რეჟიმში, Docker-ის რამდენიმე კომპონენტი განსხვავებულად მუშაობს:

Rootless რეჟიმის სწრაფი დაწყება

წინაპირობები

Docker-ის rootless რეჟიმში დასაყენებლად, დარწმუნდით, რომ თქვენი სისტემა აკმაყოფილებს შემდეგ მოთხოვნებს:

  1. Linux ბირთვის ვერსია: რეკომენდებულია 5.11 ან უფრო ახალი (მინიმუმ 4.18)
  2. მომხმარებლის სახელთა სივრცეების მხარდაჭერა: ჩართული ბირთვში (/proc/sys/kernel/unprivileged_userns_clone=1)
  3. დამხმარე პაკეტები: newuidmap, newgidmap, iptables და შესაბამისი ბიბლიოთეკები
  4. systemd (არასავალდებულო): rootless დემონის systemd მომხმარებლის სერვისად სამართავად
# ბირთვის ვერსიის შემოწმება
uname -r

# მომხმარებლის სახელთა სივრცეების მხარდაჭერის დადასტურება
cat /proc/sys/kernel/unprivileged_userns_clone

# აუცილებელი პაკეტების დაყენება Ubuntu/Debian-ზე
sudo apt-get install -y uidmap dbus-user-session iptables

ინსტალაცია

დააყენეთ Docker rootless რეჟიმში ოფიციალური ინსტალაციის სკრიპტით:

# Rootless ინსტალაციის სკრიპტის ჩამოტვირთვა და გაშვება
curl -fsSL https://get.docker.com/rootless | sh

# გარემოს ცვლადების დაყენება მიმდინარე სესიისთვის
export PATH=/usr/bin:$PATH
export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/docker.sock

დაამატეთ გარემოს ცვლადები თქვენი შელის პროფილს მუდმივობისთვის:

# დაამატეთ ~/.bashrc-ს ან ~/.profile-ს
echo "export PATH=/usr/bin:$PATH" >> ~/.bashrc
echo "export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/docker.sock" >> ~/.bashrc

ინსტალაციის ტესტირება

დაადასტურეთ, რომ rootless Docker-ის ინსტალაცია სწორად მუშაობს:

# Docker დემონის სტატუსის შემოწმება
systemctl --user status docker

# დადასტურება, რომ Docker მუშაობს root-ის გარეშე
docker info | grep -E "Context|Username"

# საცდელი კონტეინერის გაშვება
docker run --rm alpine id

ყოველდღიური ოპერაციები

დემონის მართვა

მართეთ rootless Docker დემონი systemd-ის მომხმარებლის სერვისებით:

# Docker დემონის გაშვება
systemctl --user start docker

# ავტომატური გაშვების ჩართვა
systemctl --user enable docker
loginctl enable-linger $(whoami)

# დემონის სტატუსის შემოწმება
systemctl --user status docker

# ჟურნალების ნახვა
journalctl --user -u docker

კონტეინერების მართვა

Rootless რეჟიმში კონტეინერებთან მუშაობა იყენებს სტანდარტულ Docker ბრძანებებს:

# კონტეინერის გაშვება
docker run -d --name web nginx:alpine

# გაშვებული კონტეინერების სია
docker ps

# კონტეინერის შელში შესვლა
docker exec -it web sh

# კონტეინერის გაჩერება და წაშლა
docker stop web
docker rm web

იმიჯების მართვა

იმიჯებთან ოპერაციები იგივეა, რაც სტანდარტულ Docker-ში:

# იმიჯების ჩამოტვირთვა
docker pull python:3.10-slim

# ლოკალური იმიჯების სია
docker images

# კასტომ იმიჯის აგება
docker build -t myapp:latest .

# იმიჯის წაშლა
docker rmi nginx:alpine

ქსელვა Rootless რეჟიმში

ქსელის შეზღუდვები

Rootless ქსელვას აქვს რამდენიმე მნიშვნელოვანი შეზღუდვა, რომელთა გათვალისწინებაც საჭიროა:

  1. პრივილეგირებული პორტები: 1024-ზე ქვემოთ მდებარე პორტებზე პირდაპირი მიბმა შეუძლებელია
  2. Host network რეჟიმი: შეზღუდული ფუნქციონალი root რეჟიმთან შედარებით
  3. ნაგულისხმევი CIDR: იყენებს სხვა ქვე-ქსელს სტანდარტულ Docker-თან შედარებით
  4. კონტეინერების მიერთება: ოპტიმალური მუშაობისთვის შეიძლება საჭირო გახდეს დამატებითი კონფიგურაცია

პორტების გადამისამართება

პრივილეგირებული პორტების შეზღუდვების დასაძლევად გამოიყენეთ შემდეგი მიდგომები:

# რევერს-პროქსის გამოყენება (რეკომენდებულია)
docker run -d --name nginx -p 8080:80 nginx:alpine
# შემდეგ დააკონფიგურირეთ რევერს-პროქსი, რომ გადაამისამართოს პორტი 80 პორტ 8080-ზე

# authbind-ის გამოყენება (ალტერნატიული მიდგომა)
sudo touch /etc/authbind/byport/80
sudo chmod 500 /etc/authbind/byport/80
sudo chown $(whoami) /etc/authbind/byport/80
authbind --deep dockerd-rootless

ქსელური დრაივერები

Rootless რეჟიმი მხარს უჭერს რამდენიმე ქსელურ დრაივერს განსხვავებული შესაძლებლობებით:

  1. bridge: ნაგულისხმევი დრაივერი, rootless რეჟიმში მუშაობს გარკვეული შეზღუდვებით
  2. host: შეზღუდული ფუნქციონალი rootless რეჟიმში
  3. none: სრულად მხარდაჭერილია rootless რეჟიმში
  4. macvlan/ipvlan: ზოგადად არ არის მხარდაჭერილი rootless რეჟიმში
  5. overlay: მხარდაჭერილია rootless Swarm რეჟიმში, გარკვეული შეზღუდვებით
# საკუთარი bridge ქსელის შექმნა
docker network create --driver bridge my-network

# კონტეინერის მიერთება ქსელზე
docker run -d --name db --network my-network postgres:latest

საცავის კონფიგურაცია

საცავის დრაივერები

Rootless რეჟიმი მხარს უჭერს შემდეგ საცავის დრაივერებს:

ვოლუმების მართვა

მართეთ მუდმივი მონაცემები Docker-ის ვოლუმებით rootless რეჟიმში:

# დასახელებული ვოლუმის შექმნა
docker volume create app-data

# ვოლუმის მონტაჟი კონტეინერში
docker run -d --name app -v app-data:/data alpine

# ვოლუმის დეტალების ნახვა
docker volume inspect app-data

# გამოუყენებელი ვოლუმების გასუფთავება
docker volume prune

Bind Mount-ები

Bind mount-ებს rootless რეჟიმში აქვთ ნებართვებთან დაკავშირებული თავისებურებები:

# bind mount-სთვის საქაღალდის შექმნა
mkdir -p ~/app-data

# საქაღალდის მონტაჟი კონტეინერში
docker run -d --name app -v ~/app-data:/data:Z alpine

# გაითვალისწინეთ :Z სუფიქსი, რომელიც ეხმარება SELinux კონტექსტებს

Rootless Compose და Swarm

Docker Compose Rootless რეჟიმთან

Docker Compose შეუფერხებლად მუშაობს rootless Docker-თან:

## წარმადობის განხილვები
version: '3.8'
### ბენჩმარკინგი
  web:
Rootless რეჟიმს, ზოგადად, მცირე წარმადობის ზედნადები აქვს root რეჟიმთან შედარებით:
    ports:
      - "8080:80"
# მარტივი I/O წარმადობის ტესტი
      - ./html:/usr/share/nginx/html
  
# ქსელის წარმადობის ტესტი
    build: ./api
    ports:
      - "8000:8000"
დაელოდეთ დაახლოებით 5-10%-იან ზედნადებს უმეტეს ოპერაციებზე დამატებითი სახელთა სივრცის ფენისა და userspace ქსელვის გამო.
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
### რესურსების ლიმიტები
  db:
დაადეთ რესურსების შეზღუდვები კონტეინერებს, როგორც სტანდარტულ Docker-ში:
    volumes:
      - db-data:/var/lib/postgresql/data
# CPU-სა და მეხსიერების გამოყენების შეზღუდვა
      - POSTGRES_PASSWORD=secret
      - POSTGRES_USER=user
      - POSTGRES_DB=mydb

volumes:
  db-data:

Rootless რეჟიმში კონტეინერის რესურსების ლიმიტები მაინც ექვემდებარება იმ არაპრივილეგირებული მომხმარებლის ლიმიტებს, ვინც დემონს უშვებს. Docker Compose-ის ბრძანებები ჩვეული წესით გაუშვით:

უსაფრთხოების საკითხები

### უსაფრთხოების სარგებელი
docker compose up -d
Rootless რეჟიმი რამდენიმე უსაფრთხოების გაუმჯობესებას უზრუნველყოფს:
# სერვისების სტატუსის ნახვა
1. **შეკვეცილი პრივილეგიები**: კონტეინერები და დემონი მუშაობენ root წვდომის გარეშე
2. **სახელთა სივრცის იზოლაცია**: ემატება იზოლაციის დამატებითი ფენა
3. **კონტეინერიდან გასვლის რისკის შემცირება**: თუნდაც კონტეინერი კომპრომეტირებული იყოს, შემტევს ჰოსტზე შეზღუდული წვდომა აქვს
4. **CVE-ს შემცირება**: კონტეინერის მრავალი უსაფრთხოების შეუსაბამობა root პრივილეგიებზეა დამოკიდებული

### დარჩენილი შეტევის ვექტორები
docker compose down
გაუმჯობესებების მიუხედავად, გარკვეული უსაფრთხოების საკითხები კვლავ არსებობს:

1. **ბირთვის მოწყვლადობები**: მაინც დაუცველი რჩება ბირთვის ექსპლოიტების მიმართ
2. **მომხმარებლის რესურსების კონტროლი**: ექვემდებარება მომხმარებლის რესურსების ლიმიტებსა და კვოტებს
3. **საკრედენციო მონაცემთა დაცვა**: Docker socket-ზე წვდომა მაინც საჭიროებს დაცვას
4. **დემონის პროცესის უსაფრთხოება**: თვითონ დემონი შეიძლება გახდეს მიზანი
```bash
### დამატებითი გამყყარება
docker swarm init --advertise-addr 127.0.0.1
გაიტანეთ ეს დამატებითი უსაფრთხოების ზომები:
# სერვისის შექმნა
docker service create --name web --replicas 3 --publish 8080:80 nginx:alpine
# seccomp პროფილების გამოყენება
# სერვისების სია
docker service ls
# AppArmor პროფილების გამოყენება
# სერვისის მასშტაბირება
docker service scale web=5
# შესაძლებლობების (capabilities) ჩამოჭრა rootless რეჟიმშიც
# სერვისის წაშლა
docker service rm web

Rootless რეჟიმში Swarm-ის მთავარი შეზღუდვები მოიცავს:

  1. Ingress ქსელვა: ზოგიერთი მოწინავე ფუნქცია შეიძლება შეზღუდული იყოს
  2. გარე დატვირთვის დაბალანსება: საჭიროებს დამატებით კონფიგურაციას
  3. მრავალჰოსტიანი swarm: კვანძებს შორის კომუნიკაციისთვის საჭიროა დამატებითი გაწყობა

Performance Considerations

Benchmarking

Rootless mode typically has minor performance overhead compared to root mode:

# Simple I/O performance test
time docker run --rm alpine dd if=/dev/zero of=/dev/null bs=1M count=1000

# Network performance test
docker run --rm alpine sh -c "time wget -q -O- http://example.com > /dev/null"

Expect approximately 5-10% overhead for most operations due to the additional namespace layer and user-space networking.

Resource Limits

Apply resource constraints to containers as in standard Docker:

# Limit CPU and memory usage
docker run -d --name app \
  --cpus 0.5 \
  --memory 256m \
  --memory-swap 512m \
  alpine sleep infinity

In rootless mode, container resource limits are still subject to the limits of the unprivileged user running the daemon.

Security Considerations

Security Benefits

Rootless mode provides several security enhancements:

  1. Reduced privileges: Containers and daemon run without root access
  2. Namespace isolation: Adds another layer of namespace isolation
  3. Container breakout mitigation: Even if a container is compromised, attacker has limited host access
  4. CVE reduction: Many container security vulnerabilities rely on root privileges

Remaining Attack Vectors

Despite the improvements, some security considerations remain:

  1. Kernel vulnerabilities: Still vulnerable to kernel exploits
  2. User resource controls: Subject to user resource limits and quotas
  3. Credential protection: Access to Docker socket still requires protection
  4. Daemon process security: The daemon itself could be targeted

Additional Hardening

Implement these additional security measures:

# Use seccomp profiles
docker run --security-opt seccomp=/path/to/profile.json alpine

# Apply AppArmor profiles
docker run --security-opt apparmor=my-custom-profile alpine

# Drop capabilities even in rootless mode
docker run --cap-drop ALL --cap-add NET_BIND_SERVICE alpine

Rootless რეჟიმის გაუმართაობის დიაგნოსტიკა

გავრცელებული პრობლემები

გაართვით თავი rootless რეჟიმის ამ ხშირ გამოწვევებს:

პრობლემების დიაგნოსტიკა

გამოიყენეთ ეს ბრძანებები rootless რეჟიმის პრობლემების დიაგნოსტიკისთვის:

# დემონის სტატუსის შემოწმება
systemctl --user status docker

# დეტალური ჟურნალების ნახვა
journalctl --user -u docker -n 100 --no-pager

# გარემოს კონფიგურაციის დადასტურება
env | grep -E "DOCKER|XDG"

# დემონის გაშვება გამართვის (debug) რეჟიმში
dockerd-rootless --debug

შეზღუდვები და მოპოვებები (workarounds)

ცნობილი შეზღუდვები

Rootless რეჟიმს აქვს რამდენიმე თანდაყოლილი შეზღუდვა:

  1. cgroup v1: შეზღუდული მხარდაჭერა (რეკომენდებულია cgroup v2)
  2. პრივილეგირებული კონტეინერები: სრულად პრივილეგირებული არ არის root რეჟიმთან შედარებით
  3. NFS მონტაჟები: შეზღუდული მხარდაჭერა root დირექტორიებად
  4. ქსელური შესაძლებლობები: ზოგიერთი მოწინავე ფუნქცია მიუწვდომელია
  5. Swarm შესაძლებლობები: გარკვეული შეზღუდვები მრავალჰოსტიან განლაგებებში

პრაქტიკული მიდგომები (workarounds)

გამოიყენეთ ეს მიდგომები გავრცელებული შეზღუდვების დასძლევად:

# პრივილეგირებულ პორტებზე მიბმისთვის
sudo setcap cap_net_bind_service=ep $(which rootlesskit)

# cgroup მხარდაჭერის გასაძლიერებლად
sudo mkdir -p /etc/systemd/system/[email protected]
cat <<EOF | sudo tee /etc/systemd/system/[email protected]/delegate.conf
[Service]
Delegate=yes
EOF
sudo systemctl daemon-reload

წარმოებაში დანერგვის საკითხები

სისტემის კონფიგურაცია

ოპტიმიზაცია გაუკეთეთ თქვენს სისტემას rootless წარმოებაში დანერგვებისთვის:

# გაზარდეთ მომხმარებლის რესურსების ლიმიტები /etc/security/limits.conf ფაილში
username soft nofile 65536
username hard nofile 65536
username soft nproc 4096
username hard nproc 4096

# ჩართეთ user lingering systemd-სთვის
sudo loginctl enable-linger username

# დააკონფიგურირეთ ბირთვის პარამეტრები /etc/sysctl.conf-ში
kernel.unprivileged_userns_clone=1
net.ipv4.ip_unprivileged_port_start=80

მონიტორინგი და ლოგირება

დააკონფიგურირეთ ყოვლისმომცველი მონიტორინგი rootless დანერგვებისთვის:

# ჟურნალების გადამისამართების დაყენება
dockerd-rootless --log-driver=json-file --log-opt max-size=10m --log-opt max-file=3

# Prometheus endpoint-ის კონფიგურაცია
dockerd-rootless --metrics-addr 127.0.0.1:9323

სარეზერვო კოპირების სტრატეგია

გაიტანეთ სარეზერვო კოპირების სტრატეგია rootless Docker გარემოებისთვის:

# Docker-ის მონაცემთა დირექტორიის პოვნა
docker info | grep "Docker Root Dir"

# სარეზერვო სკრიპტის შექმნა
#!/bin/bash
DOCKER_DIR=$(docker info | grep "Docker Root Dir" | cut -d: -f2 | tr -d '[:space:]')
BACKUP_DIR="/path/to/backups"
TIMESTAMP=$(date +%Y%m%d%H%M%S)

# დემონის გაჩერება
systemctl --user stop docker

# სარეზერვო კოპიის შექმნა
tar -czf $BACKUP_DIR/docker-rootless-$TIMESTAMP.tar.gz $DOCKER_DIR

# დემონის გადატვირთვა
systemctl --user start docker

საუკეთესო პრაქტიკები და რეკომენდაციები

უსაფრთხოების საუკეთესო პრაქტიკები

მოიყვანეთ ეს უსაფრთხოების რეკომენდაციები rootless დანერგვებისთვის:

  1. განაახლეთ: რეგულარულად განაახლეთ Docker და ჰოსტ ოპერაციული სისტემა
  2. სკანირება იმიჯებზე: გამოიყენეთ Trivy-ის მსგავსი ინსტრუმენტები მოწყვლადობების აღმოსაჩენად
  3. უმცირესი პრივილეგია: გამოიყენეთ მინიმალური capabilities rootless რეჟიმშიც
  4. seccomp/AppArmor: გამოიყენეთ დამატებითი შეზღუდვები
  5. წვდომის აუდიტი: აკონტროლეთ და აუდიტეთ Docker socket-ზე წვდომა

წარმადობის ოპტიმიზაცია

ოპტიმიზაცია გაუკეთეთ rootless Docker-ის წარმადობას ამ სტრატეგიებით:

  1. გამოიყენეთ overlay2: არჩევთ overlay2-ს, როცა შესაძლებელია
  2. ჩართეთ cgroup v2: უზრუნველყოფს რესურსების უკეთეს მართვას
  3. დააკონფიგურირეთ slirp4netns: მოასწორეთ MTU და სხვა პარამეტრები ქსელის წარმადობისთვის
  4. საკმარისი რესურსები: გამოუყავით საკმარისი მეხსიერება დემონის მომხმარებელს
  5. ვოლუმების მონტაჟი: გამოიყენეთ volumes bind mount-ის ნაცვლად უკეთესი წარმადობისთვის

მიგრაციის სტრატეგია

არსებული დანერგვების rootless რეჟიმზე გადაყვანისას:

  1. გულდასმით დატესტეთ: გადაამოწმეთ ყველა ფუნქციონალი სატესტო გარემოში
  2. ინკრემენტული მიდგომა: პირველ რიგში გადაიყვანეთ არა-კრიტიკული სამუშაოები
  3. ავტომატიზაციის განახლება: მოარგეთ CI/CD পাইპლაინები და დანერგვის სკრიპტები
  4. ცვლილებების დოკუმენტირება: შეინარჩუნეთ განსხვავებების მკაფიო დოკუმენტაცია
  5. ტრენინგი: უზრუნველყეთ, რომ გუნდმა გაიგოს rootless რეჟიმის მუშაობა

დასკვნა

Docker-ის Rootless რეჟიმი წარმოადგენს მნიშვნელოვან წინგადადგმულ ნაბიჯს კონტეინერების უსაფრთხოებაში და მოაქვს უმცირესი პრივილეგიის პრინციპი კონტეინერიზებულ აპლიკაციებში. Docker-ის დემონისა და კონტეინერების root პრივილეგიების გარეშე გაშვებით, ორგანიზაციები მნიშვნელოვნად ამცირებენ შეტევის ზედაპირს და ამსუბუქებენ პოტენციური „container breakout“-ის გავლენას.

მიუხედავად იმისა, რომ rootless რეჟიმი გარკვეულ შეზღუდვებსა და სირთულეებს შემოაქვს, უსაფრთხოების სარგებელი ამად ღირს ბევრ საპროდუქციო გარემოში, განსაკუთრებით მკაცრი უსაფრთხოების მოთხოვნებისა და მულტითენანტ სცენარების შემთხვევაში. Rootless რეჟიმის მზარდი სიმწიფე აგრძელებს საწყისი შეზღუდვების აღმოფხვრას და უფრო და უფრო სიცოცხლისუნარიანს ხდის მას ფართო დანერგვისთვის.

ამ ამომწურავი გზამკვლევის რეკომენდაციების მიყოლებით, შეძლებთ წარმატებით დანერგოთ Docker-ის Rootless რეჟიმი როგორც განვითარებისა, ისე წარმოების გარემოებში, გააძლიეროთ კონტეინერების უსაფრთხოება და შეინარჩუნოთ Docker-ის მოქნილობა და მოხერხებულობა.