Docker სერვისების აღმოჩენა და DNS

# კონტეინერის გაშვება ქასთომ ჰოსთნეიმით
docker run -d --name web --hostname web.local nginx

# კონტეინერის გამოძახება მისი ჰოსთნეიმით
docker exec -it web ping web.local

# ნაგულისხმევი bridge — კონტეინერებს შორის DNS რეზოლუცია არ მუშაობს
docker run -d --name container1 nginx
docker run -d --name container2 nginx

# ეს ჩაიშლება — ნაგულისხმევ bridge-ზე კონტეინერის სახელები არ რეზოლვდება
docker exec -it container1 ping container2

# მომხმარებლის მიერ განსაზღვრული bridge ქსელის შექმნა
docker network create app-network

# არსებული კონტეინერების მიერთება ქსელზე
docker network connect app-network container1
docker network connect app-network container2

# ახლა DNS რეზოლუცია მუშაობს
docker exec -it container1 ping container2

# swarm-ის ინიციალიზაცია
docker swarm init --advertise-addr 192.168.1.10

# სერვისის გაშლა swarm-ზე
docker service create --name api --replicas 3 --network app-network myapp-api:latest

# სერვისი ხელმისაწვდომია სახელით app-network-ის ნებისმიერ კონტეინერიდან
docker exec -it client curl http://api:8080/

# docker-compose.yml
version: '3'
services:
  web:
    image: nginx:latest
    depends_on:
      - api
  
  api:
    image: myapp-api:latest
    depends_on:
      - database
  
  database:
    image: postgres:14
    environment:
      POSTGRES_PASSWORD: example

# web კონტეინერის შიგნით
curl http://api:8000/

# api კონტეინერის შიგნით
psql -h database -U postgres

# docker-compose.yml ქასთომ ქსელვით
version: '3'
services:
  web:
    image: nginx:latest
    networks:
      - frontend
      - backend
  
  api:
    image: myapp-api:latest
    networks:
      - backend
  
  database:
    image: postgres:14
    networks:
      - backend
    environment:
      POSTGRES_PASSWORD: example

networks:
  frontend:
  backend:
  internal: true  # გარე კავშირი არ არის

# Consul-ის docker-compose.yml
version: '3'
services:
  consul:
    image: consul:latest
    ports:
      - "8500:8500"
    command: agent -server -bootstrap-expect=1 -ui -client=0.0.0.0
    volumes:
      - consul-data:/consul/data

  service-registrator:
    image: gliderlabs/registrator:latest
    depends_on:
      - consul
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock
    command: -internal consul://consul:8500

volumes:
  consul-data:

# სერვისის ხელით რეგისტრაცია
curl -X PUT -d '{
  "ID": "api-1",
  "Name": "api",
  "Address": "172.17.0.3",
  "Port": 8080,
  "Check": {
    "HTTP": "http://172.17.0.3:8080/health",
    "Interval": "10s"
  }
}' http://localhost:8500/v1/agent/service/register

# etcd-სთვის docker-compose.yml
version: '3'
services:
  etcd:
    image: bitnami/etcd:latest
    environment:
      - ALLOW_NONE_AUTHENTICATION=yes
      - ETCD_ADVERTISE_CLIENT_URLS=http://etcd:2379
    ports:
      - "2379:2379"
    volumes:
      - etcd-data:/bitnami/etcd

volumes:
  etcd-data:

# სერვისის endpoint-ის რეგისტრაცია
docker exec -it etcd etcdctl put /services/api/node1 '{"host": "172.17.0.3", "port": 8080}'

# სერვისის endpoint-ების გამოთხოვა
docker exec -it etcd etcdctl get --prefix /services/api

# CoreDNS-ის docker-compose.yml
version: '3'
services:
  coredns:
    image: coredns/coredns:latest
    ports:
      - "53:53/udp"
    volumes:
      - ./Corefile:/Corefile
    command: -conf /Corefile

.:53 {
    errors
    health
    ready
    hosts {
        172.17.0.3 api.service.local
        172.17.0.4 redis.service.local
        172.17.0.5 postgres.service.local
        fallthrough
    }
    forward . 8.8.8.8
    cache 30
    loop
    reload
}

# Overlay ქსელის შექმნა
docker network create --driver overlay --attachable services

# სერვისის გაშლა ქსელზე
docker service create \
  --name api \
  --network services \
  --replicas 3 \
  myapp-api:latest

# სერვისის ინსპექტირება VIP-ის სანახავად
docker service inspect --format '{{json .Endpoint.VirtualIPs}}' api

# DNS Round Robin-ით სერვისის შექმნა
docker service create \
  --name api \
  --network services \
  --endpoint-mode dnsrr \
  --replicas 3 \
  myapp-api:latest

# Istio-ს დეპლოი ინტეგრირებული DNS-ით
istioctl install --set profile=demo

# სერვისის დეპლოი ჩართული service discovery-ით
kubectl apply -f - <<EOF
apiVersion: v1
kind: Service
metadata:
  name: api
  labels:
    app: api
spec:
  ports:
  - port: 80
    name: http
  selector:
    app: api
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
      - name: api
        image: myapp-api:latest
        ports:
        - containerPort: 80
EOF

# Dnsmasq-ის docker-compose.yml
version: '3'
services:
  dnsmasq:
    image: jpillora/dnsmasq
    ports:
      - "53:53/udp"
    environment:
      - HTTP_USER=admin
      - HTTP_PASS=admin
    volumes:
      - ./dnsmasq.conf:/etc/dnsmasq.conf

# dnsmasq.conf
address=/api.local/172.17.0.3
address=/database.local/172.17.0.4
address=/cache.local/172.17.0.5

# Docker Compose ჯანმრთელობის შემოწმებებით
version: '3'
services:
  api:
    image: myapp-api:latest
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

# სერვისის შექმნა ჯანმრთელობის შემოწმებით
docker service create \
  --name api \
  --health-cmd "curl -f http://localhost:8080/health || exit 1" \
  --health-interval 30s \
  --replicas 3 \
  myapp-api:latest

// Circuit Breaking-ის მაგალითი Go-ში resilience4j-ის გამოყენებით
import (
    "github.com/eapache/go-resiliency/breaker"
    "time"
    "net/http"
)

func main() {
  // Circuit breaker, რომელიც ჩაირთვება 5 ზედიზედ შეცდომის შემდეგ
  // და 10 წამში დაბრუნდება საწყის მდგომარეობაში
    cb := breaker.New(5, 1, 10*time.Second)
    
    err := cb.Run(func() error {
        resp, err := http.Get("http://api:8080/endpoint")
        if err != nil {
            return err
        }
        defer resp.Body.Close()
        if resp.StatusCode >= 500 {
            return fmt.Errorf("server error: %d", resp.StatusCode)
        }
        return nil
    })
    
    if err != nil {
  // შეცდომის დამუშავება ან გახსნილი ციკლის მდგომარეობა
    }
}

# docker-compose.yml ქსელის სეგმენტაციით
version: '3'
services:
  frontend:
    image: myapp-frontend:latest
    networks:
      - frontend
      - services
  
  api:
    image: myapp-api:latest
    networks:
      - services
      - data
  
  database:
    image: postgres:14
    networks:
      - data
    environment:
      POSTGRES_PASSWORD: example

networks:
  frontend:
    driver: bridge
  services:
    driver: bridge
    internal: false
  data:
    driver: bridge
  internal: true  # გარე წვდომა არ არის

# Consul-ის docker-compose.yml ACL-ებით
version: '3'
services:
  consul:
    image: consul:latest
    ports:
      - "8500:8500"
    command: agent -server -bootstrap-expect=1 -ui -client=0.0.0.0 -acl-enable
    environment:
      - CONSUL_HTTP_TOKEN=your-master-token
    volumes:
      - ./consul-acl.json:/consul/config/acl.json

// consul-acl.json
{
  "acl": {
    "enabled": true,
    "default_policy": "deny",
    "down_policy": "extend-cache",
    "tokens": {
      "master": "your-master-token"
    }
  }
}

# docker-compose.yml TLS კონფიგურაციით
version: '3'
services:
  api:
    image: myapp-api:latest
    volumes:
      - ./certs:/certs
    environment:
      - SSL_CERT_FILE=/certs/server.crt
      - SSL_KEY_FILE=/certs/server.key
      - SSL_CA_FILE=/certs/ca.crt

# Consul კლასტერის ჯანმრთელობის შემოწმება
curl http://localhost:8500/v1/health/service/consul

# სერვისის რეგისტრაციის გადამოწმება
curl http://localhost:8500/v1/catalog/service/api

# DNS რეზოლუციის შემოწმება
dig @127.0.0.1 -p 8600 api.service.consul SRV