# ახალი swarm-ის ინიციალიზაცია (მენეჯერ კვანძზე)
docker swarm init --advertise-addr <MANAGER-IP>
# --advertise-addr მიუთითებს მისამართს, რომელსაც სხვა კვანძები გამოიყენებენ ამ მენეჯერთან დასაკავშირებლად
# თუ გამოტოვებულია, Docker-ი შეეცდება IP-ის ავტომატურად აღმოჩენას, რაც შეიძლება არასწორი იყოს მრავალ-ინტერფეისიან სერვერებზე

# გამოტანილი შედეგი მოგცემთ ტოკენს მუშა კვანძების დასამატებლად
# მაგალითი:
# docker swarm join --token SWMTKN-1-49nj1cmql0jkz5s954yi3oex3nedyz0fb0xx14ie39trti4wxv-8vxv8rssmk743ojnwacrr2e7c <MANAGER-IP>:2377
# ეს ტოკენი ახდენს ახალი კვანძების ავთენტიფიკაციას swarm-ში, რაც უზრუნველყოფს კლასტერის უსაფრთხო გაფართოებას

# კვანძის დამატება როგორც მუშა
docker swarm join --token <TOKEN> <MANAGER-IP>:2377
# მუშა კვანძები იღებენ და ასრულებენ დავალებებს, მაგრამ არ შეუძლიათ კლასტერის მდგომარეობის მართვა
# პორტი 2377 არის swarm-ის მართვის სტანდარტული პორტი

# კვანძის დამატება როგორც მენეჯერი
docker swarm join-token manager
# ეს ბრძანება აგენერირებს სხვა ტოკენს სპეციალურად მენეჯერი კვანძებისთვის
# შემდეგ გამოიყენეთ მოწოდებული ტოკენი მენეჯერად დასამატებლად
docker swarm join --token <MANAGER-TOKEN> <MANAGER-IP>:2377
# მენეჯერი კვანძები მონაწილეობენ Raft კონსენსუსში და შეუძლიათ კლასტერის მართვა

# კვანძების სია swarm-ში
docker node ls
# აჩვენებს ყველა კვანძს მათი როლებით, ხელმისაწვდომობის სტატუსით და მენეჯერის სტატუსით
# MANAGER STATUS სვეტი აჩვენებს "Leader"-ს მთავარი მენეჯერი კვანძისთვის

# რეპლიცირებული სერვისის შექმნა
docker service create --name webserver \
  --replicas 3 \
                        # კონტეინერის 3 ინსტანციის გაშვება
  --publish 80:80 \
                      # პორტ 80-ის გამოქვეყნება ყველა swarm კვანძზე
  --update-delay 10s \
                  # თითოეული კონტეინერის განახლებას შორის 10 წამის დაყოვნება
  --update-parallelism 1 \
              # ერთ ჯერზე ერთი კონტეინერის განახლება
  --restart-condition on-failure \
      # ავტომატურად გადატვირთეთ კონტეინერები, რომლებიც არა-ნულოვანი კოდით გამოდიან
  nginx:latest                          # გამოსაყენებელი კონტეინერის იმიჯი

# სერვისების სია
docker service ls
# აჩვენებს ყველა სერვისს მათი ID-ით, სახელით, რეჟიმით (replicated/global), რეპლიკებით, იმიჯით და პორტებით

# სერვისის შემოწმება
docker service inspect webserver
# აბრუნებს სერვისის კონფიგურაციის დეტალურ JSON-ს, მათ შორის:
# - კონტეინერის კონფიგურაცია
# - რესურსების შეზღუდვები
# - ქსელები
# - განახლებისა და დაბრუნების (rollback) კონფიგურაცია
# - განთავსების შეზღუდვები

# სერვისის დავალებების (კონტეინერების) ნახვა
docker service ps webserver
# აჩვენებს სერვისის ყველა დავალებას (კონტეინერს) მათი:
# - ID-ით, სახელით, იმიჯით
# - კვანძზე მინიჭებით
# - სასურველი და მიმდინარე მდგომარეობით
# - შეცდომის შეტყობინებებით (თუ არსებობს)
# - როდის შეიქმნა და განახლდა დავალება

# სერვისის მასშტაბირება
docker service scale webserver=5
# ზრდის ან ამცირებს რეპლიკების რაოდენობას
# Swarm-ი შექმნის ან წაშლის კონტეინერებს სასურველი რაოდენობის შესაბამისად
# გამოიყენეთ მძიმით გამოყოფილი სია მრავალი სერვისის მასშტაბირებისთვის: webserver=5,api=3

# სერვისის განახლება
docker service update --image nginx:1.21 \
  --limit-cpu 0.5 \
                        # CPU ლიმიტების დამატება
  --limit-memory 512M \
                      # მეხსიერების ლიმიტების დამატება
  --rollback-parallelism 2 \
                # დაბრუნების ქცევის კონფიგურაცია
  webserver

# სერვისის წაშლა
docker service rm webserver
# შლის სერვისს და აჩერებს ყველა დაკავშირებულ კონტეინერს

# სერვისების აღმოჩენის მაგალითი
docker service create --name db \
  --network backend-network \
                # ოვერლეი ქსელში გაწევრიანება
  --mount type=volume,source=db-data,target=/var/lib/postgresql/data \
               # მუდმივი საცავი
  --env POSTGRES_PASSWORD_FILE=/run/secrets/db_password \
               # საიდუმლოებების გამოყენება უსაფრთხოებისთვის
  --replicas 1 \
                             # მონაცემთა ბაზა ჩვეულებრივ ერთ ინსტანციას აწარმოებს
  postgres:13                               # მონაცემთა ბაზის იმიჯი

docker service create --name api \
  --network backend-network \
                # იგივე ქსელი, რაც db სერვისს
  --env DB_HOST=db \
                        # მონაცემთა ბაზაზე მითითება სერვისის სახელით
  --env DB_PORT=5432 \
                      # სტანდარტული PostgreSQL პორტი
  --replicas 3 \
                            # მრავალი API ინსტანციის გაშვება
  --update-order start-first \
              # განახლებისას ახალი დავალებების დაწყება ძველების შეჩერებამდე
  myapi:latest                              # API იმიჯი

# მონაცემთა ბაზასთან დაკავშირება api კონტეინერის შიგნიდან
docker exec -it $(docker ps -q -f name=api) bash
ping db       # გადაიჭრება სერვისის VIP-ად
psql -h db -U postgres -d myapp  # მონაცემთა ბაზასთან დაკავშირება სერვისის სახელით

# ფრონტენდ სერვისის შექმნა, რომელიც უკავშირდება API-ს
docker service create --name frontend \
  --network backend-network \
  --env API_URL=http://api:8000/ \
  # API სერვისის სახელი ავტომატურად გადაიჭრება და დატვირთვა დაბალანსდება
  --publish 80:80 \
  frontend:latest

# docker-compose.yml Swarm-ის გაშვებისთვის
version: '3.8'  # Compose ფაილის ფორმატის ვერსია swarm-ის მხარდაჭერით

services:
  web:
    image: nginx:latest
    ports:
      - "80:80"  # გამოქვეყნებული პორტი (ხელმისაწვდომია გარედან)
    deploy:
      mode: replicated       # 'replicated' (მასშტაბირებული) ან 'global' (ერთი თითო კვანძზე)
      replicas: 3            # კონტეინერის ინსტანციების რაოდენობა
      update_config:
        parallelism: 1       # ერთ ჯერზე ერთი კონტეინერის განახლება
        delay: 10s           # განახლებებს შორის 10 წამის დაყოვნება
        order: start-first   # ახალი დავალებების დაწყება ძველების შეჩერებამდე
        failure_action: rollback  # ავტომატური დაბრუნება შეცდომისას
      restart_policy:
        condition: on-failure    # გადატვირთვა, თუ კონტეინერი არა-ნულოვანი კოდით გამოვა
        max_attempts: 3          # გადატვირთვის მაქსიმალური მცდელობა
        window: 120s             # დროის ფანჯარა გადატვირთვის მცდელობების შესაფასებლად
      placement:
        constraints:
          - node.role == worker  # მხოლოდ მუშა კვანძებზე გაშვება
        preferences:
          - spread: node.labels.datacenter  # მონაცემთა ცენტრებში განაწილება
      resources:
        limits:
          cpus: '0.5'       # CPU-ს მაქსიმალური გამოყენება
          memory: 512M      # მეხსიერების მაქსიმალური გამოყენება
        reservations:
          cpus: '0.1'       # გარანტირებული CPU-ს გამოყოფა
          memory: 128M      # გარანტირებული მეხსიერების გამოყოფა
  
  api:
    image: myapi:latest
    deploy:
      replicas: 3
      placement:
        constraints:
          - node.labels.zone == frontend  # მხოლოდ ამ ლეიბლის მქონე კვანძებზე გაშვება
        max_replicas_per_node: 1          # ინსტანციების შეზღუდვა თითო კვანძზე HA-სთვის
      update_config:
        parallelism: 2                    # ერთდროულად ორი კონტეინერის განახლება
      rollback_config:
        parallelism: 3                    # საჭიროების შემთხვევაში უფრო სწრაფი დაბრუნება
    environment:
      - DB_HOST=db                     # სერვისის აღმოჩენა სახელით
      - API_KEY_FILE=/run/secrets/api_key  # საიდუმლოზე მითითება
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s                # საწყისი საშეღავათო პერიოდი
    networks:
      - backend                        # backend ქსელთან დაკავშირება
    secrets:
      - api_key                        # ქვემოთ განსაზღვრულ საიდუმლოზე მითითება
  
  db:
    image: postgres:13
    volumes:
      - db-data:/var/lib/postgresql/data  # მუდმივი საცავი
    deploy:
      placement:
        constraints:
          - node.labels.zone == database  # მხოლოდ მონაცემთა ბაზის კვანძებზე გაშვება
      replicas: 1                         # ერთი მონაცემთა ბაზის ინსტანცია
      restart_policy:
        condition: any                    # ყოველთვის გადატვირთვა
    environment:
      - POSTGRES_PASSWORD_FILE=/run/secrets/db_password
    networks:
      - backend
    secrets:
      - db_password

networks:
  backend:
    driver: overlay               # მრავალ-ჰოსტიანი ქსელი
    attachable: true              # დამოუკიდებელ კონტეინერებს დაკავშირების საშუალება
    driver_opts:
      encrypted: "true"           # ამ ქსელზე ტრაფიკის დაშიფვრა

volumes:
  db-data:
    driver: local                 # ლოკალური საცავის გამოყენება (ნაგულისხმევი)
    # პროდაქშენისთვის, განიხილეთ დისკის დრაივერის გამოყენება, რომელსაც რეპლიკაციის მხარდაჭერა აქვს

secrets:
  api_key:
    file: ./secrets/api_key.txt   # ლოკალური ფაილიდან ჩატვირთვა გაშვებისას
  db_password:
    file: ./secrets/db_password.txt

# საიდუმლოს შექმნა
echo "mypassword" | docker secret create db_password -
# საიდუმლოებები ინახება დაშიფრული სახით Raft ლოგში
# ისინი არასოდეს იწერება დისკზე დაშიფვრის გარეშე
# `-` ბოლოს მიუთითებს stdin-დან შეყვანას

# სერვისის შექმნა საიდუმლოთი
docker service create --name db \
  --secret db_password \
                           # შექმნილ საიდუმლოზე მითითება
  --env POSTGRES_PASSWORD_FILE=/run/secrets/db_password \
                           # აპლიკაციისთვის მითითება, სად იპოვოს იგი
  --secret source=ssl_cert,target=server.crt \
                           # საიდუმლოსთვის მორგებული სამიზნე გზა
  --secret source=ssl_key,target=server.key,mode=0400 \
                           # მორგებული ფაილის უფლებები
  postgres:13

# კონტეინერის შიგნით, საიდუმლოებები ჩანს როგორც ფაილები /run/secrets/-ში
# მაგალითი:
# /run/secrets/db_password
# /run/secrets/server.crt
# /run/secrets/server.key

# საიდუმლოებების სია
docker secret ls
# აჩვენებს ყველა საიდუმლოს შექმნის დროითა და ID-ით

# საიდუმლოს შემოწმება (აჩვენებს მხოლოდ მეტამონაცემებს, არა რეალურ შინაარსს)
docker secret inspect db_password

# საიდუმლოს წაშლა
docker secret rm db_password
# შენიშვნა: არ შეიძლება გაშვებული სერვისების მიერ გამოყენებული საიდუმლოებების წაშლა
# ჯერ უნდა განაახლოთ ან წაშალოთ სერვისები

# საიდუმლოს შექმნა ფაილიდან
docker secret create ssl_cert ./server.crt

# სერვისის შექმნა რესურსების შეზღუდვებით
docker service create --name resource-limited \
  --limit-cpu 0.5 \
                    # CPU-ს მაქსიმალური გამოყენება (ერთი ბირთვის 50%)
  --limit-memory 512M \
                    # მეხსიერების მაქსიმალური გამოყენება (512MB)
  --reserve-cpu 0.2 \
                    # გარანტირებული CPU (ერთი ბირთვის 20%)
  --reserve-memory 256M \
                    # გარანტირებული მეხსიერება (256MB)
  --reserve-memory-swap 512M \
                   # მეხსიერების+swap-ის მთლიანი რეზერვაცია
  --generic-resource "gpu=1" \
                   # 1 GPU-ს მოთხოვნა (მოითხოვს კვანძის ლეიბლებს)
  --ulimit nofile=65536:65536 \
                  # ფაილის დესკრიპტორების ლიმიტების დაყენება
  --ulimit nproc=4096:4096 \
                   # პროცესების ლიმიტები
  nginx:latest

# რესურსების შეზღუდვები უზრუნველყოფენ:
# 1. რესურსების სამართლიან განაწილებას სერვისებს შორის
# 2. დაცვას ხმაურიანი მეზობლებისგან
# 3. პროგნოზირებად წარმადობას
# 4. კონტეინერების ეფექტურ შეფუთვას

# გრაფიკის შემდგენელი იყენებს რეზერვაციებს განთავსების გადაწყვეტილებების მისაღებად
# ლიმიტები აწესებენ რესურსების მაქსიმალურ გამოყენებას
# კვანძს უნდა ჰქონდეს რეზერვაციის შესაბამისი ხელმისაწვდომი რესურსები

# კვანძების სია
docker node ls
# გამოტანილი შედეგი აჩვენებს:
# - NODE ID: თითოეული კვანძის უნიკალური იდენტიფიკატორი
# - HOSTNAME: კვანძის ჰოსტის სახელი
# - STATUS: Ready, Down, ან Disconnected
# - AVAILABILITY: Active, Pause, ან Drain
# - MANAGER STATUS: Leader, Reachable, ან Unreachable (მენეჯერი კვანძებისთვის)
# - ENGINE VERSION: Docker-ის ძრავის ვერსია

# კვანძის შემოწმება
docker node inspect node-1
# აბრუნებს დეტალურ ინფორმაციას კვანძის შესახებ:
# - ლეიბლები და კვანძის ატრიბუტები
# - რესურსების ხელმისაწვდომობა
# - პლატფორმა და არქიტექტურა
# - ქსელის მისამართები
# - შეერთების ტოკენები და სერთიფიკატები
# - სტატუსი და ჯანმრთელობა

# შემოწმების შედეგის ფორმატირება კონკრეტული ინფორმაციისთვის
docker node inspect -f '{{.Status.Addr}}' node-1
# აბრუნებს მხოლოდ კვანძის IP მისამართს

# კვანძის ხელმისაწვდომობის დაყენება
docker node update --availability drain node-1  # მომზადება ტექნიკური სამუშაოებისთვის
# Drain: აჩერებს ახალი დავალებების დაგეგმვას და შლის არსებულ დავალებებს კვანძიდან
# არსებული დავალებები შეუფერხებლად გადაიგეგმება სხვა კვანძებზე
# იდეალურია ტექნიკური სამუშაოებისა და განახლებებისთვის

docker node update --availability active node-1 # სერვისში დაბრუნება
# Active: კვანძი იღებს ახალ დავალებებს და ინარჩუნებს არსებულებს
# Pause: კვანძი ინარჩუნებს არსებულ დავალებებს, მაგრამ არ მიიღებს ახლებს

# კვანძებზე ლეიბლების დამატება
docker node update --label-add zone=frontend node-1
docker node update --label-add datacenter=east --label-add cpu=high-performance node-1
# ლეიბლები საშუალებას იძლევა რთული დაგეგმვის სტრატეგიების:
# - გეოგრაფიული განაწილება
# - აპარატურის დიფერენციაცია
# - გარემოს გამოყოფა (prod/staging)
# - სპეციალიზებული დატვირთვის მიზნობრიობა

# კვანძების ფილტრაცია ლეიბლებით
docker node ls --filter node.label=zone=frontend

# მუშა კვანძის მენეჯერად დაწინაურება
docker node promote node-2
# მუშა კვანძს გარდაქმნის მენეჯერის როლში
# უერთდება Raft კონსენსუსის ჯგუფს
# იღებს კლასტერის მდგომარეობის ასლს
# ახლა შეუძლია მართვის ბრძანებების მიღება

# მენეჯერის მუშა კვანძად დაქვეითება
docker node demote node-2
# შლის კვანძს მართვის პანელიდან
# თუ ეს დაარღვევს კვორუმს, ოპერაცია ვერ შესრულდება
# საუკეთესო პრაქტიკა: დააქვეითეთ მენეჯერი კვანძების წაშლამდე

# კვანძის წაშლა swarm-იდან
# ჯერ, წასაშლელ კვანძზე:
docker swarm leave
# შემდეგ მენეჯერ კვანძზე:
docker node rm node-3

# swarm-ის მდგომარეობის სარეზერვო ასლის შექმნა (მენეჯერ კვანძზე)
# ჯერ, შექმენით სრული სარეზერვო ასლი
tar -czvf swarm-backup.tar.gz /var/lib/docker/swarm
# ეს მოიცავს:
# - Raft ლოგებსა და კონსენსუსის მონაცემებს
# - TLS სერთიფიკატებსა და გასაღებებს
# - საიდუმლო მონაცემებს (დაშიფრული)
# - კვანძის ინფორმაციასა და შეერთების ტოკენებს

# უფრო სრულყოფილი სარეზერვო ასლისთვის, ჩართეთ:
docker service ls > services.txt
docker service inspect $(docker service ls -q) > service-details.json
docker secret ls > secrets.txt
docker config ls > configs.txt
docker network ls --filter driver=overlay > networks.txt

# swarm-ის აღდგენა
# 1. შეაჩერეთ Docker-ი მენეჯერზე
systemctl stop docker

# 2. აღადგინეთ სარეზერვო ასლი
tar -xzvf swarm-backup.tar.gz -C /
# სარეზერვო ასლი უნდა აღდგეს იმავე გზის სტრუქტურაზე

# 3. გაუშვით Docker-ი
systemctl start docker
# Docker-ი ინიციალიზაციას მოახდენს აღდგენილი swarm-ის მდგომარეობის გამოყენებით
# კვანძი განაახლებს თავის როლს (ლიდერი ან მიმდევარი)

# 4. შეამოწმეთ აღდგენა
docker node ls
docker service ls

# ალტერნატიული სარეზერვო ასლის მიდგომა მენეჯერის UCP-ის გამოყენებით
# შეინახეთ UCP სარეზერვო ფაილი, რომელიც მოიცავს swarm-ის კონფიგურაციას
docker container run --log-driver none --rm -i --name ucp \
  -v /var/run/docker.sock:/var/run/docker.sock \
  docker/ucp:latest backup --id $(docker container ls -q --filter name=ucp-controller) \
  --passphrase "secret" > ucp-backup.tar.gz