Docker Desktop და განვითარების გარემო

ინსტალაცია

• პლატფორმის-სპეციფიკური ინსტალერები: სხვადასხვა საინსტალაციო პაკეტები, ოპტიმიზირებული Windows-ისთვის (WSL2 ინტეგრაციით), macOS-ისთვის (Intel და Apple Silicon) და Linux-ისთვის
• სისტემური მოთხოვნები: მინიმუმ 4GB RAM, 2 CPU ბირთვი და 20GB დისკზე ადგილი; Windows 10/11 Pro/Enterprise ან WSL2 Home ვერსიაზე; macOS 10.15+ ან Apple Silicon
• დესკტოპის კონფიგურაციის ოპციები: რესურსების, ფაილების გაზიარების, ქსელის პარამეტრების და Kubernetes-ის კონფიგურაციის მორგება
• ოპერაციულ სისტემასთან ინტეგრაცია: ბუნებრივი ინტეგრაცია Windows-ის, macOS-ისა და Linux-ის ფაილურ სისტემებთან, ქსელთან და ავთენტიფიკაციასთან
• გაფართოებების მართვა: ჩაშენებული მარკეტი Docker-ის გაფართოებებისთვის ფუნქციონალის და სამუშაო პროცესების ინტეგრაციის გასაუმჯობესებლად

ძირითადი მახასიათებლები

• კონტეინერების მართვის UI: ინტუიციური გრაფიკული ინტერფეისი კონტეინერების დასაწყებად, შესაჩერებლად და მონიტორინგისთვის
• იმიჯების დათვალიერება და მართვა: ვიზუალური ინსტრუმენტები კონტეინერის იმიჯების შესასწავლად, გადმოსაწერად, ასაწყობად და გასასუფთავებლად
• Docker Hub-თან ინტეგრაცია: უწყვეტი წვდომა საჯარო და კერძო რეპოზიტორიებთან რწმუნებათა მართვით
• დისკების და ქსელების მართვა: Docker-ის დისკების და ქსელების შექმნა, კონფიგურაცია და მონიტორინგი UI-ის საშუალებით
• ინტეგრირებული Kubernetes: ჩაშენებული ერთ-კვანძიანი Kubernetes კლასტერი, რომელიც საშუალებას იძლევა მარტივად გადართოთ Docker Swarm-სა და Kubernetes-ს შორის
• დაფის ანალიტიკა: კონტეინერის რესურსების გამოყენების, ლოგების და ჯანმრთელობის სტატუსის რეალურ დროში მონიტორინგი
• Dev Environments: ერთობლივი განვითარების გარემო, რომელიც შეიძლება გაზიარდეს გუნდებს შორის

რესურსები

# რესურსების განაწილების მაგალითი settings.json-ში
{
  "cpus": 4,                # Docker VM-ისთვის გამოყოფილი CPU ბირთვების რაოდენობა
  "memory": "8 GB",         # Docker-ის ძრავისთვის გამოყოფილი RAM
  "swap": "1 GB",           # დამატებითი swap სივრცე მეხსიერების ინტენსიური ოპერაციებისთვის
  "diskSize": "60 GB",      # ვირტუალური დისკის ზომა კონტეინერების შესანახად
  "dataFolder": "/path/to/custom/docker-data",  # მონაცემების მორგებული მდებარეობა
  "memorySwap": "9 GB",     # მთლიანი მეხსიერება swap-ის ჩათვლით (memory + swap)
  "diskImage": "/path/to/docker-disk.raw" # დისკის იმიჯის მორგებული მდებარეობა
}

რესურსების განაწილება პირდაპირ გავლენას ახდენს Docker-ის მუშაობაზე:

• არასაკმარისი CPU: კონტეინერის ნელი გაშვება და ბილდის დრო
• შეზღუდული მეხსიერება: კონტეინერის კრახი მეხსიერების გადავსების შეცდომებით
• დისკის მცირე ზომა: "No space left on device" შეცდომები ბილდების დროს
• რესურსების სწორი განაწილება ხელს უშლის წარმადობის პრობლემებს

ფაილების გაზიარება

• გაზიარებული საქაღალდეების კონფიგურაცია: მიუთითეთ რომელი ჰოსტის დირექტორიებია ხელმისაწვდომი კონტეინერებისთვის
  # settings.json-ში ან UI-ის საშუალებით
  "filesharingDirectories": [
    "/Users/username/projects",
    "/Volumes/data"
  ]
  

• ჰოსტის ფაილებზე წვდომა კონტეინერებიდან: ჰოსტის დირექტორიების დამონტაჟება როგორც დისკები კონტეინერებში
  docker run -v /Users/username/projects:/app myimage
  

• წარმადობის მოსაზრებები: სხვადასხვა წარმადობის მახასიათებლები პლატფორმების მიხედვით
  • Windows/WSL2: საუკეთესო წარმადობა WSL2 ფაილურ სისტემაში
  • macOS: ნელი წარმადობა osxfs-ის გამო gRPC FUSE-ით ფაილების გასაზიარებლად
  • Linux: თითქმის ბუნებრივი წარმადობა მინიმალური დანახარჯებით
• ფაილური სისტემის იზოლაცია: აკონტროლეთ რომელი დირექტორიებია ხელმისაწვდომი კონტეინერებისთვის უსაფრთხოების მიზნით
  • შერჩევითი გაზიარება ხელს უშლის მგრძნობიარე ჰოსტის ფაილების გამოვლენას
  • გამოიყენეთ bind mounts-ი დეველოპმენტისთვის, დასახელებული დისკები (named volumes) პროდაქშენისთვის
  • macOS-ზე წარმადობისთვის განიხილეთ delegated/cached mount-ის ოპციების გამოყენება

ქსელი

• პორტების გადამისამართება: კონტეინერის სერვისების გამოჩენა ჰოსტის ქსელში
  # პორტების ავტომატური გადამისამართება ან კონფიგურაცია docker-compose.yml-ში
  docker run -p 8080:80 nginx  # კონტეინერის პორტ 80-ს ამისამართებს ჰოსტის პორტ 8080-ზე
  

• DNS კონფიგურაცია: მორგებული DNS სერვერების კონფიგურაცია კონტეინერის რეზოლუციისთვის
  {
    "dns": ["8.8.8.8", "1.1.1.1"],
    "dns-search": ["example.com"]
  }
  

• პროქსის პარამეტრები: HTTP/HTTPS პროქსის კონფიგურაცია კონტეინერის ინტერნეტთან წვდომისთვის
  {
    "httpProxy": "http://proxy.example.com:8080",
    "httpsProxy": "http://proxy.example.com:8080",
    "noProxy": "localhost,127.0.0.1,.example.com"
  }
  

• ქსელის დრაივერის შერჩევა: აირჩიეთ შესაბამისი ქსელის დრაივერები სხვადასხვა გამოყენების შემთხვევებისთვის
  • bridge: ნაგულისხმევი იზოლირებული ქსელი კონტეინერებისთვის (ნაგულისხმევი)
  • host: ჰოსტის ქსელის პირდაპირი გამოყენება (უფრო მაღალი წარმადობა, დაბალი იზოლაცია)
  • overlay: მრავალ-ჰოსტიანი ქსელი Swarm/Kubernetes-ისთვის
  • macvlan: MAC მისამართების მინიჭება კონტეინერებისთვის ფიზიკურ ქსელში გამოსაჩენად
  • none: ქსელის გათიშვა მაქსიმალური იზოლაციისთვის

Git რეპოზიტორიიდან

1. დააჭირეთ "Create" Dev Environments-ში: შედით შექმნის ოსტატში Docker Desktop-იდან
2. მიუთითეთ Git რეპოზიტორიის URL: შეიყვანეთ Git რეპოზიტორია, რომელიც შეიცავს Docker-ის კონფიგურაციას
   https://github.com/username/project.git
   

3. გარემოს პარამეტრების კონფიგურაცია: დააყენეთ რესურსების ლიმიტები, დისკის მონტაჟი და გარემოს ცვლადები
   # გარემოს მორგებადი პარამეტრები
   resources:
     cpus: 2
     memory: 4GB
   volumeMounts:
     - source: ~/.ssh
       target: /home/user/.ssh
       readonly: true
   

4. გარემოს დაწყება: Docker-ი იღებს რეპოზიტორიას და აშენებს განვითარების კონტეინერს
   # კულისებში, Docker-ი აწარმოებს:
   git clone https://github.com/username/project.git
   docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d
   

5. დაკავშირება VS Code-ით ან სხვა IDE-ით: გახსენით კოდი თქვენს სასურველ რედაქტორში კონტეინერის ინტეგრაციით
   # VS Code-ისთვის
   code --folder-uri vscode-remote://attached-container+name=project_dev
   # ან გამოიყენეთ "Open in VS Code" ღილაკი Docker Desktop-ში
   

ლოკალური საქაღალდიდან

1. აირჩიეთ "Create From Local Folder": გამოიყენეთ არსებული კოდი თქვენს მანქანაზე
2. აირჩიეთ პროექტის დირექტორია: აირჩიეთ საქაღალდე, რომელიც შეიცავს თქვენს კოდს
   # Docker Desktop-ი ამ დირექტორიას ამონტაჟებს dev გარემოში
   /Users/username/projects/my-application
   

3. Docker Compose-ის პარამეტრების კონფიგურაცია: მოარგეთ, თუ როგორ აშენდება გარემო
   # Docker Desktop-ი აგენერირებს ან იყენებს არსებულ docker-compose.yml-ს
   services:
     app:
       build: .
       volumes:
         - .:/app
         - ~/.aws:/home/user/.aws:ro
       ports:
         - "3000:3000"
       environment:
         - NODE_ENV=development
   

4. გარემოს გაშვება: Docker-ი აშენებს და იწყებს განვითარების კონტეინერს
   # Docker-ი ასრულებს ამ ოპერაციებს:
   docker-compose build  # ნებისმიერი მორგებული იმიჯის აგება
   docker-compose up -d  # გარემოს დაწყება
   

5. განვითარების დაწყება: დაიწყეთ კოდირება ჰოსტ-კონტეინერის ფაილების სინქრონიზაციით
   # თქვენს ლოკალურ დირექტორიაში ცვლილებები დაუყოვნებლივ აისახება კონტეინერში
   # სამუშაო პროცესის მაგალითი:
   vim src/app.js  # ფაილის რედაქტირება ლოკალურად
   docker-compose exec app npm test  # ტესტების გაშვება კონტეინერში
   

Dockerfile განვითარებისთვის

FROM node:16

WORKDIR /app

# განვითარების დამოკიდებულებების ინსტალაცია
COPY package*.json ./
RUN npm install

# კონტეინერის გაშვებულ მდგომარეობაში შენარჩუნება
CMD ["npm", "run", "dev"]

VS Code ინტეგრაცია

// .devcontainer/devcontainer.json
{
  "name": "Node.js Development",
  "dockerComposeFile": "../docker-compose.yaml",
  "service": "app",
  "workspaceFolder": "/app",
  "extensions": [
    "dbaeumer.vscode-eslint",
    "esbenp.prettier-vscode"
  ],
  "settings": {
    "terminal.integrated.shell.linux": "/bin/bash"
  }
}

Bind Mounts

• კოდის რეალურ დროში განახლებები: საწყის კოდში ცვლილებები დაუყოვნებლივ ჩანს კონტეინერებში
  # კოდის რედაქტირება ჰოსტზე, კონტეინერი მყისიერად ხედავს ცვლილებებს
  docker run -v $(pwd)/src:/app/src node:16 npm run dev
  

• ბუნებრივი ფაილურ სისტემაზე წვდომა: კონტეინერის პროცესებს შეუძლიათ ჰოსტის ფაილების პირდაპირ წაკითხვა/წერა
  volumes:
    - ./src:/app/src  # საწყისი დირექტორიის პირდაპირი მიბმა
    - ./config:/app/config:ro  # მხოლოდ წაკითხვის უფლებით წვდომა კონფიგურაციაზე
  

• განვითარების სამუშაო პროცესთან ინტეგრაცია: მუშაობს IDE-ებთან, ლინტერებთან და სხვა დეველოპერულ ინსტრუმენტებთან
  # VSCode-ს შეუძლია ფაილებზე წვდომა, სანამ კონტეინერი კოდს აწარმოებს
  volumes:
    - .:/app  # მთელი პროექტის დამონტაჟება IDE ინტეგრაციისთვის
  

• წარმადობის მოსაზრებები OS-ის მიხედვით:
  • Windows WSL2-ით: თითქმის ბუნებრივი წარმადობა, როდესაც ფაილები WSL2 ფაილურ სისტემაშია
  • Windows Hyper-V-ით: ნელი წარმადობა ფაილური სისტემის თარგმნის გამო
  • macOS: 10-20-ჯერადი წარმადობის დანაკარგი I/O-ინტენსიური ოპერაციებისთვის
  • Linux: საუკეთესო წარმადობა მინიმალური დანახარჯებით
  # macOS-ის წარმადობის ოპტიმიზაცია
  volumes:
    - ./src:/app/src:delegated  # აუმჯობესებს წარმადობას ჰოსტის განახლებების დაყოვნებით
  

• გზების მიბმის კონფიგურაცია: დააკონფიგურირეთ ზუსტი მიბმა ჰოსტისა და კონტეინერის გზებს შორის
  volumes:
    # აბსოლუტური გზები
    - /Users/developer/projects/myapp:/app
    # ფარდობითი გზები (docker-compose.yml-ის მიმართ)
    - ./logs:/app/logs
    # სახლის დირექტორიის მითითებები
    - ~/configs:/app/configs
  

დისკის ტიპები

# დასახელებული დისკი (დამოკიდებულებებისთვის და ბილდის არტეფაქტებისთვის)
docker run -v my_node_modules:/app/node_modules -v .:/app node:16

# Bind mount (საწყისი კოდისთვის)
docker run -v $(pwd):/app -w /app node:16 npm run dev

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

• კონტეინერების დაწყება/შეჩერება
• კონტეინერის ლოგების ნახვა
• კონტეინერის ტერმინალზე წვდომა
• კონტეინერის რესურსების მონიტორინგი
• კონტეინერის გადატვირთვის პოლიტიკები

გაფართოებები განვითარებისთვის

• მონაცემთა ბაზების მართვა
• API ტესტირება
• კონტეინერების სკანირება
• კოდის რედაქტირება
• რესურსების მონიტორინგი

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

• გამოიყენეთ მრავალ-ეტაპიანი ბილდები
• დანერგეთ .dockerignore
• დისკის მონტაჟის ოპტიმიზაცია
• რესურსების ლიმიტების კონფიგურაცია
• გამოიყენეთ buildkit-ი უფრო სწრაფი ბილდებისთვის

გუნდური სამუშაო პროცესები

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

Kubernetes ინტეგრაცია

• Kubernetes-ის ჩართვა პარამეტრებში: გაააქტიურეთ ჩაშენებული Kubernetes კლასტერი
  # settings.json-ში ან UI-ის საშუალებით
  {
    "kubernetes": {
      "enabled": true,
      "showSystemContainers": false
    }
  }
  

• განთავსება ლოკალურ კლასტერზე: შეამოწმეთ Kubernetes-ის დეპლოიმენტები ლოკალურად პროდაქშენამდე
  # აპლიკაციის განთავსება ლოკალურ Kubernetes-ზე
  kubectl apply -f kubernetes/deployment.yaml
  
  # პოდების მონიტორინგი
  kubectl get pods -w
  
  # სერვისებზე წვდომა (ავტომატურად კონფიგურირებულია Docker Desktop-ში)
  curl localhost:8080
  

• kubectl-ის გამოყენება Docker Desktop-ის საშუალებით: ინტეგრირებული kubectl ცალკე ინსტალაციის გარეშე
  # Docker Desktop-ი ავტომატურად აყენებს kubectl კონტექსტს
  kubectl config current-context
  # docker-desktop
  
  # ყველა სტანდარტული kubectl ბრძანება მუშაობს
  kubectl get nodes
  kubectl get namespaces
  kubectl describe deployment my-app
  

• დაფასთან ინტეგრაცია: Kubernetes-ის რესურსებზე წვდომა Docker Desktop-ის UI-დან
  # Kubernetes-ის ჩანართი აჩვენებს:
  - Deployments
  - Pods
  - Services
  - ConfigMaps
  - Secrets
  - ლოგები და მოვლენები
  

• კონტექსტის გადართვა: მარტივად გადართეთ სხვადასხვა Kubernetes კლასტერებს შორის
  # კონტექსტის გადართვა
  kubectl config use-context docker-desktop
  
  # ხელმისაწვდომი კონტექსტების ნახვა
  kubectl config get-contexts
  
  # Docker Desktop-ი ანახლებს თავის UI-ს მიმდინარე კონტექსტის მიხედვით
  

• რესურსების მართვა: გამოუყავით შესაბამისი რესურსები Kubernetes-ს
  // Settings.json
  {
    "kubernetes": {
      "cpus": 2,
      "memory": "4GB",
      "enabled": true
    }
  }
  

WSL 2 ინტეგრაცია (Windows)

• გაუმჯობესებული წარმადობა: მნიშვნელოვნად სწრაფია, ვიდრე ძველი Hyper-V ბექენდი
  # WSL 2 ბექენდი გთავაზობთ თითქმის ბუნებრივ Linux-ის წარმადობას
  # ბილდის წარმადობის შედარების მაგალითი:
  # ძველი: docker build . -t myapp  # ~120 წამი
  # WSL 2:  docker build . -t myapp  # ~45 წამი
  

• Linux კონტეინერების მხარდაჭერა: გაუშვით Linux კონტეინერები ბუნებრივად ემულაციის გარეშე
  # WSL 2 აწარმოებს ნამდვილ Linux-ის ბირთვს
  docker exec -it mycontainer uname -a
  # Linux containerhost 5.10.102.1-microsoft-standard-WSL2 #1 SMP...
  

• ფაილურ სისტემაზე წვდომა: უმაღლესი წარმადობა, როდესაც ფაილები WSL 2 ფაილურ სისტემაშია
  # საუკეთესო წარმადობა პროექტებით WSL ფაილურ სისტემაში
  # WSL ტერმინალში:
  cd ~/projects/myapp
  docker run -v $(pwd):/app node:16 npm run build  # სწრაფი I/O
  
  # Windows-ის გზების მონტაჟი კვლავ მხარდაჭერილია, მაგრამ უფრო ნელია
  docker run -v /c/Users/username/projects/myapp:/app node:16 npm run build
  

• რესურსების გაზიარება: მეხსიერების ეფექტური გაზიარება ჰოსტსა და Docker-ს შორის
  # .wslconfig-ში
  [wsl2]
  memory=8GB
  processors=4
  swap=2GB
  # Docker-ი ავტომატურად იყენებს ამ რესურსებს
  

• ტერმინალთან ინტეგრაცია: უწყვეტი ბრძანების ხაზის გამოცდილება
  # გაუშვით WSL ტერმინალი პირდაპირ Docker Desktop-იდან
  # ან გამოიყენეთ Windows Terminal-იდან, Docker-ის კონტექსტი უკვე დაყენებულია
  
  # გაუშვით Docker-ის ბრძანებები პირდაპირ WSL-ში
  wsl docker ps
  wsl docker-compose up -d
  
  # გამოიყენეთ VSCode WSL-თან და Docker-ის ინტეგრაციასთან ერთად
  code --remote wsl
  

• დისტრიბუციის ოპციები: WSL დისტრიბუციების არჩევანი Docker-ის ბექენდისთვის
  // Settings.json
  {
    "wslEngineEnabled": true,
    "wslDistro": "Ubuntu-20.04"  # აირჩიეთ კონკრეტული დისტრიბუცია
  }