# Dockerfile ქასთომ MySQL კონფიგურაციისთვის
FROM mysql:8.0
    # ... მთავარი მონაცემთა ბაზის კონფიგურაცია ...
# ქასთომ MySQL კონფიგურაციის დამატება
COPY my-custom.cnf /etc/mysql/conf.d/

# ინიციალიზაციის სკრიპტების დამატება
COPY init-scripts/ /docker-entrypoint-initdb.d/

# Healthcheck-ის დაყენება
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
  CMD mysqladmin ping -h localhost -u healthcheck_user --password=$MYSQL_HEALTHCHECK_PASSWORD || exit 1

MySQL-ის კონტეინერიზაციის საკვანძო მოსაზრებები:

  ### Prometheus-ით მონიტორინგი
2. **ინიციალიზაციის სკრიპტები**: გამოიყენეთ `/docker-entrypoint-initdb.d/` ბაზის საწყისი გამართვისთვის
  კონტეინერიზებული ბაზებისთვის Prometheus მონიტორინგის გამართვა:
4. **ავთენტიკაციის პლაგინები**: დააყენეთ შესაბამისი ავთენტიკაციის მექანიზმები
5. **ჯანმრთელობის შემოწმებები**: დანერგეთ სწორი health monitoring

### PostgreSQL

PostgreSQL-ის კონტეინერიზაცია მოითხოვს ყურადღებას PostgreSQL-ის სპეციფიკურ მოთხოვნებზე:

```yaml
version: '3.8'

services:
  postgres:
    image: postgres:15
    container_name: postgres_db
    restart: unless-stopped
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_DB: ${POSTGRES_DB}
      PGDATA: /var/lib/postgresql/data/pgdata
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./postgresql.conf:/etc/postgresql/postgresql.conf
      - ./pg_hba.conf:/etc/postgresql/pg_hba.conf
    command: postgres -c 'config_file=/etc/postgresql/postgresql.conf'
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G

volumes:
  postgres_data:
    driver: local

version: '3.8'

services:
  mongo:
    image: mongo:6.0
    container_name: mongodb
    restart: unless-stopped
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${MONGO_ROOT_USER}
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_ROOT_PASSWORD}
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db
      - mongo_config:/data/configdb
      - ./init-scripts:/docker-entrypoint-initdb.d
      - ./mongod.conf:/etc/mongod.conf
    command: ["--config", "/etc/mongod.conf"]
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/admin -u $${MONGO_ROOT_USER} -p $${MONGO_ROOT_PASSWORD} --quiet | grep 1
      interval: 10s
      timeout: 10s
      retries: 5
      start_period: 40s

volumes:
  mongo_data:
    driver: local
  mongo_config:
    driver: local

version: '3.8'

services:
  redis:
    image: redis:7.0-alpine
    container_name: redis_cache
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
      - ./redis.conf:/usr/local/etc/redis/redis.conf:ro
    command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
    deploy:
      resources:
        limits:
          memory: 1G
    sysctls:
      net.core.somaxconn: '511'
      vm.overcommit_memory: '1'

volumes:
  redis_data:
    driver: local

version: '3.8'

services:
  mysql_primary:
    image: mysql:8.0
    container_name: mysql_primary
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    ports:
      - "3306:3306"
    volumes:
      - mysql_primary_data:/var/lib/mysql
      - ./primary.cnf:/etc/mysql/conf.d/custom.cnf:ro
    networks:
      - mysql_network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

  mysql_replica:
    image: mysql:8.0
    container_name: mysql_replica
    restart: unless-stopped
    depends_on:
      mysql_primary:
        condition: service_healthy
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    ports:
      - "3307:3306"
    volumes:
      - mysql_replica_data:/var/lib/mysql
      - ./replica.cnf:/etc/mysql/conf.d/custom.cnf:ro
      - ./setup-replica.sh:/docker-entrypoint-initdb.d/setup-replica.sh
    networks:
      - mysql_network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  mysql_primary_data:
  mysql_replica_data:

networks:
  mysql_network:
    driver: bridge

[mysqld]
server-id = 1
log_bin = mysql-bin
binlog_format = ROW
binlog_do_db = ${MYSQL_DATABASE}

[mysqld]
server-id = 2
relay_log = mysql-relay-bin
log_bin = mysql-bin
binlog_format = ROW
read_only = ON

#!/bin/bash
set -e

# გავიცადოთ, სანამ MySQL primary მზად იქნება
until mysql -h mysql_primary -u root -p${MYSQL_ROOT_PASSWORD} -e "SELECT 1"; do
  echo "Waiting for MySQL primary to be ready..."
  sleep 5
done

# ბინარული ლოგის პოზიციის მიღება primary-დან
MASTER_STATUS=$(mysql -h mysql_primary -u root -p${MYSQL_ROOT_PASSWORD} -e "SHOW MASTER STATUS\G")
BINLOG_FILE=$(echo "$MASTER_STATUS" | grep File | awk '{print $2}')
BINLOG_POSITION=$(echo "$MASTER_STATUS" | grep Position | awk '{print $2}')

# რეპლიკაციის კონფიგურაცია
mysql -u root -p${MYSQL_ROOT_PASSWORD} << EOF
CHANGE MASTER TO
  MASTER_HOST='mysql_primary',
  MASTER_USER='${MYSQL_USER}',
  MASTER_PASSWORD='${MYSQL_PASSWORD}',
  MASTER_LOG_FILE='$BINLOG_FILE',
  MASTER_LOG_POS=$BINLOG_POSITION;
START SLAVE;
EOF

echo "Replica configured and started"

version: '3.8'

services:
  postgres_primary:
    image: postgres:15
    container_name: postgres_primary
    restart: unless-stopped
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_DB: ${POSTGRES_DB}
      PGDATA: /var/lib/postgresql/data/pgdata
    ports:
      - "5432:5432"
    volumes:
      - postgres_primary_data:/var/lib/postgresql/data
      - ./primary.conf:/etc/postgresql/postgresql.conf:ro
      - ./pg_hba.conf:/etc/postgresql/pg_hba.conf:ro
    command: postgres -c 'config_file=/etc/postgresql/postgresql.conf'
    networks:
      - postgres_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5

  postgres_standby:
    image: postgres:15
    container_name: postgres_standby
    restart: unless-stopped
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_DB: ${POSTGRES_DB}
      PGDATA: /var/lib/postgresql/data/pgdata
    ports:
      - "5433:5432"
    volumes:
      - postgres_standby_data:/var/lib/postgresql/data
      - ./standby.conf:/etc/postgresql/postgresql.conf:ro
      - ./pg_hba.conf:/etc/postgresql/pg_hba.conf:ro
      - ./setup-replica.sh:/docker-entrypoint-initdb.d/setup-replica.sh
    command: postgres -c 'config_file=/etc/postgresql/postgresql.conf'
    networks:
      - postgres_network
    depends_on:
      postgres_primary:
        condition: service_healthy

volumes:
  postgres_primary_data:
  postgres_standby_data:

networks:
  postgres_network:
    driver: bridge

version: '3.8'

services:
  mongo1:
    image: mongo:6.0
    container_name: mongo1
    restart: unless-stopped
    command: ["--replSet", "rs0", "--bind_ip_all"]
    ports:
      - "27017:27017"
    volumes:
      - mongo1_data:/data/db
      - ./init-replica.js:/docker-entrypoint-initdb.d/init-replica.js:ro
    networks:
      - mongo_network
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017 --quiet | grep 1
      interval: 10s
      timeout: 10s
      retries: 5
      start_period: 40s

  mongo2:
    image: mongo:6.0
    container_name: mongo2
    restart: unless-stopped
    command: ["--replSet", "rs0", "--bind_ip_all"]
    ports:
      - "27018:27017"
    volumes:
      - mongo2_data:/data/db
    networks:
      - mongo_network
    depends_on:
      - mongo1

  mongo3:
    image: mongo:6.0
    container_name: mongo3
    restart: unless-stopped
    command: ["--replSet", "rs0", "--bind_ip_all"]
    ports:
      - "27019:27017"
    volumes:
      - mongo3_data:/data/db
    networks:
      - mongo_network
    depends_on:
      - mongo1

volumes:
  mongo1_data:
  mongo2_data:
  mongo3_data:

networks:
  mongo_network:
    driver: bridge

// გავიცადოთ, სანამ ყველა კვანძი გახდება ხელმისაწვდომი
const waitForNodes = (hosts, attempts = 30) => {
  let attempt = 0;
  
  while (attempt < attempts) {
    try {
      for (const host of hosts) {
        const conn = new Mongo(host);
        const status = conn.getDB("admin").runCommand({ ping: 1 });
  if (status.ok !== 1) throw new Error(`ვერ მოხერხდა დაკავშირება: ${host}`);
  print(`წარმატებით დავუკავშირდით: ${host}`);
      }
      return true;
    } catch (err) {
  print(`ცდა ${attempt + 1}/${attempts}: ${err.message}`);
      sleep(5000);
      attempt++;
    }
  }
  
  throw new Error("ვერ მოხერხდა ყველა კვანძთან დაკავშირება");
};

// replica set-ის ინიციალიზაცია
const initReplSet = () => {
  try {
    waitForNodes(["mongo1:27017", "mongo2:27017", "mongo3:27017"]);
    
  print("Replica set-ის კონფიგურაცია...");
    const rsConfig = {
      _id: "rs0",
      members: [
        { _id: 0, host: "mongo1:27017", priority: 2 },
        { _id: 1, host: "mongo2:27017", priority: 1 },
        { _id: 2, host: "mongo3:27017", priority: 1 }
      ]
    };
    
    rs.initiate(rsConfig);
    
  print("Replica set-ის ინიციალიზაციის მოლოდინი...");
    sleep(5000);
    
  // სტატუსის შემოწმება
    const status = rs.status();
    printjson(status);
    
  print("Replica set-ის ინიციალიზაცია დასრულებულია!");
  } catch (err) {
  print(`Replica set-ის ინიციალიზაციის შეცდომა: ${err.message}`);
    throw err;
  }
};

// ინიციალიზაციის გაშვება
initReplSet();

version: '3.8'

services:
  postgres:
    image: postgres:15
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 4G
        reservations:
          cpus: '1'
          memory: 2G
  # ... სხვა კონფიგურაცია ...

  mysql:
    image: mysql:8.0
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 4G
        reservations:
          cpus: '1'
          memory: 2G
  # ... სხვა კონფიგურაცია ...

version: '3.8'

services:
  postgres:
  # ... სხვა კონფიგურაცია ...
    volumes:
      - type: volume
        source: postgres_data
        target: /var/lib/postgresql/data
        volume:
          nocopy: true
      - type: tmpfs
        target: /dev/shm
        tmpfs:
          size: 1G
    sysctls:
      vm.swappiness: 0
      vm.dirty_ratio: 80
      vm.dirty_background_ratio: 5

volumes:
  postgres_data:
    driver: local
    driver_opts:
      type: 'ext4'
      device: '/dev/sdb1'
      o: 'noatime,nodiratime'

# ბექაპ კონტეინერის გაშვება ბაზის snapshot-ისთვის
docker run --rm \
  --volumes-from postgres_db \
  -v $(pwd)/backups:/backups \
  alpine \
  tar czf /backups/postgres_data_$(date +%Y%m%d_%H%M%S).tar.gz /var/lib/postgresql/data

version: '3.8'

services:
  postgres:
    # ... main database configuration ...

  postgres_backup:
    image: postgres:15
    depends_on:
      - postgres
    volumes:
      - ./backups:/backups
      - ./backup-scripts:/scripts
    environment:
      PGPASSWORD: ${POSTGRES_PASSWORD}
    entrypoint: /scripts/backup.sh
    deploy:
      restart_policy:
        condition: none

#!/bin/bash
set -e

# ცვლადები
BACKUP_DIR="/backups"
POSTGRES_HOST="postgres"
POSTGRES_DB="${POSTGRES_DB:-postgres}"
POSTGRES_USER="${POSTGRES_USER:-postgres}"
DATE=$(date +"%Y%m%d_%H%M%S")
BACKUP_FILE="${BACKUP_DIR}/${POSTGRES_DB}_${DATE}.sql.gz"

# დავრწმუნდეთ, რომ ბექაპის დირექტორია არსებობს
mkdir -p ${BACKUP_DIR}

# ბექაპის შექმნა
echo "ვქმნით ბექაპს ${POSTGRES_DB} ბაზისთვის ჰოსტიდან ${POSTGRES_HOST}..."
pg_dump -h ${POSTGRES_HOST} -U ${POSTGRES_USER} ${POSTGRES_DB} | gzip > ${BACKUP_FILE}

# ბექაპის შემოწმება
if [ -f "${BACKUP_FILE}" ]; then
  echo "ბექაპი წარმატებით დასრულდა: ${BACKUP_FILE}"
  echo "ბექაპის ზომა: $(du -h ${BACKUP_FILE} | cut -f1)"
else
  echo "ბექაპი ვერ შესრულდა!"
  exit 1
fi

# ძველი ბექაპების გასუფთავება (შეინახეთ ბოლო 7 დღე)
find ${BACKUP_DIR} -name "${POSTGRES_DB}_*.sql.gz" -type f -mtime +7 -delete

version: '3.8'

services:
  # ... მთავარი მონაცემთა ბაზის სერვისები ...
  
  backup_scheduler:
    image: alpine
    volumes:
      - ./backups:/backups
      - /var/run/docker.sock:/var/run/docker.sock
    command: |
      sh -c "
        apk add --no-cache docker-cli
        echo '0 2 * * * docker-compose exec -T mysql mysqldump -u root -p$$MYSQL_ROOT_PASSWORD --all-databases | gzip > /backups/mysql_all_$$(date +\%Y\%m\%d).sql.gz' > /etc/crontabs/root
        crond -f -d 8
      "
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}

version: '3.8'

services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./pg_hba.conf:/etc/postgresql/pg_hba.conf:ro
    secrets:
      - postgres_password

secrets:
  postgres_password:
    file: ./postgres_password.txt

# TYPE  DATABASE        USER            ADDRESS                 METHOD
local   all             postgres                                peer
host    all             all             127.0.0.1/32            scram-sha-256
host    all             all             ::1/128                 scram-sha-256
host    all             all             172.16.0.0/12           scram-sha-256
host    all             all             0.0.0.0/0               reject

version: '3.8'

services:
  mysql:
    image: mysql:8.0
    volumes:
      - mysql_data:/var/lib/mysql
      - ./ssl:/etc/mysql/ssl:ro
    command:
      - --ssl-ca=/etc/mysql/ssl/ca.pem
      - --ssl-cert=/etc/mysql/ssl/server-cert.pem
      - --ssl-key=/etc/mysql/ssl/server-key.pem
      - --require-secure-transport=ON

# 1. მიმდინარე ბაზის ბექაპის შექმნა
docker exec postgres_db pg_dumpall -c -U postgres > postgres_backup.sql

# 2. მიმდინარე კონტეინერის გაჩერება
docker-compose stop postgres

# 3. docker-compose.yml-ში იმიჯის ვერსიის განახლება postgres:14-იდან postgres:15-მდე

# 4. ახალი ვერსიის გაშვება
docker-compose up -d postgres

# 5. განახლების გადამოწმება
docker exec postgres_db psql -U postgres -c "SELECT version();"

version: '3.8'

services:
  postgres:
    # ... მთავარი მონაცემთა ბაზის კონფიგურაცია ...

  flyway:
    image: flyway/flyway:9
    command: -url=jdbc:postgresql://postgres:5432/${POSTGRES_DB} -user=${POSTGRES_USER} -password=${POSTGRES_PASSWORD} migrate
    volumes:
      - ./migrations:/flyway/sql
    depends_on:
      postgres:
        condition: service_healthy

version: '3.8'

services:
  mysql:
    image: mysql:8.0
    # ... სხვა კონფიგურაცია ...
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "healthcheck_user", "--password=$$MYSQL_HEALTHCHECK_PASSWORD"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 30s
  
  postgres:
    image: postgres:15
    # ... სხვა კონფიგურაცია ...
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 10s
  
  mongodb:
    image: mongo:6.0
    # ... სხვა კონფიგურაცია ...
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/admin -u $${MONGO_INITDB_ROOT_USERNAME} -p $${MONGO_INITDB_ROOT_PASSWORD} --quiet | grep 1
      interval: 10s
      timeout: 10s
      retries: 5
      start_period: 40s

version: '3.8'

services:
  postgres:
    # ... main database configuration ...

  postgres_exporter:
    image: prometheuscommunity/postgres-exporter
    environment:
      DATA_SOURCE_NAME: "postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}?sslmode=disable"
    ports:
      - "9187:9187"
    depends_on:
      - postgres

  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'

  grafana:
    image: grafana/grafana
    depends_on:
      - prometheus
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./dashboards:/etc/grafana/provisioning/dashboards
      - ./datasources:/etc/grafana/provisioning/datasources

volumes:
  postgres_data:
  prometheus_data:
  grafana_data:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'postgres'
    static_configs:
      - targets: ['postgres_exporter:9187']

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
spec:
  serviceName: "postgres"
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:15
        ports:
        - containerPort: 5432
          name: postgres
        env:
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: postgres-secrets
              key: password
        - name: POSTGRES_USER
          value: postgres
        - name: POSTGRES_DB
          value: myapp
        - name: PGDATA
          value: /var/lib/postgresql/data/pgdata
        volumeMounts:
        - name: postgres-data
          mountPath: /var/lib/postgresql/data
        readinessProbe:
          exec:
            command: ["pg_isready", "-U", "postgres"]
          initialDelaySeconds: 5
          periodSeconds: 10
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
  volumeClaimTemplates:
  - metadata:
      name: postgres-data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 10Gi
---
apiVersion: v1
kind: Service
metadata:
  name: postgres
spec:
  selector:
    app: postgres
  ports:
  - port: 5432
    targetPort: 5432
  clusterIP: None

# მართვად RDS ბაზასთან მიერთების მაგალითი კონტეინერიზებული აპლიკაციიდან
version: '3.8'

services:
  app:
    image: myapp:latest
    environment:
      DB_HOST: mydb.cluster-abcdefghijkl.us-east-1.rds.amazonaws.com
      DB_PORT: 5432
      DB_NAME: myapp
      DB_USER: app_user
      DB_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password

secrets:
  db_password:
    external: true

version: '3.8'

services:
  influxdb:
    image: influxdb:2.6
    container_name: influxdb
    restart: unless-stopped
    ports:
      - "8086:8086"
    volumes:
      - influx_data:/var/lib/influxdb2
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=${INFLUXDB_USERNAME}
      - DOCKER_INFLUXDB_INIT_PASSWORD=${INFLUXDB_PASSWORD}
      - DOCKER_INFLUXDB_INIT_ORG=${INFLUXDB_ORG}
      - DOCKER_INFLUXDB_INIT_BUCKET=${INFLUXDB_BUCKET}
      - DOCKER_INFLUXDB_INIT_RETENTION=${INFLUXDB_RETENTION}
    healthcheck:
      test: ["CMD", "influx", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s

volumes:
  influx_data:

version: '3.8'

services:
  neo4j:
    image: neo4j:5.5
    container_name: neo4j
    restart: unless-stopped
    ports:
  - "7474:7474"  # HTTP ინტერფეისი
  - "7687:7687"  # Bolt პროტოკოლი
    volumes:
      - neo4j_data:/data
      - neo4j_logs:/logs
      - neo4j_import:/var/lib/neo4j/import
      - neo4j_plugins:/plugins
      - ./neo4j.conf:/conf/neo4j.conf
    environment:
      - NEO4J_AUTH=neo4j/${NEO4J_PASSWORD}
      - NEO4J_dbms_memory_pagecache_size=1G
      - NEO4J_dbms_memory_heap_initial__size=1G
      - NEO4J_dbms_memory_heap_max__size=2G
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://localhost:7474"]
      interval: 1m
      timeout: 10s
      retries: 3
      start_period: 40s

volumes:
  neo4j_data:
  neo4j_logs:
  neo4j_import:
  neo4j_plugins:

version: '3.8'

services:
  dev_db:
    image: postgres:15-alpine
    restart: unless-stopped
    environment:
      POSTGRES_PASSWORD: devpassword
      POSTGRES_USER: devuser
      POSTGRES_DB: devdb
    ports:
      - "5432:5432"
    volumes:
      - dev_db_data:/var/lib/postgresql/data
      - ./init-scripts:/docker-entrypoint-initdb.d
    command: >
      -c max_connections=100
      -c shared_buffers=256MB
      -c effective_cache_size=512MB
      -c log_statement=all
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U devuser -d devdb"]
      interval: 5s
      timeout: 3s
      retries: 3

volumes:
  dev_db_data:

version: '3.8'

services:
  test_db:
    image: postgres:15-alpine
    environment:
      POSTGRES_PASSWORD: testpassword
      POSTGRES_USER: testuser
      POSTGRES_DB: testdb
    ports:
      - "5433:5432"
    volumes:
      - ./test-fixtures:/docker-entrypoint-initdb.d
    tmpfs:
      - /var/lib/postgresql/data
    command: >
      -c fsync=off
      -c full_page_writes=off
      -c synchronous_commit=off
  
  integration_tests:
    image: myapp-tests:latest
    depends_on:
      test_db:
        condition: service_healthy
    environment:
      DB_HOST: test_db
      DB_PORT: 5432
      DB_NAME: testdb
      DB_USER: testuser
      DB_PASSWORD: testpassword
    volumes:
      - ./test-results:/app/test-results

# ლოკალური დეველოპმენტისთვის docker-compose.override.yml
version: '3.8'

services:
  postgres:
    ports:
      - "5432:5432"
    environment:
      POSTGRES_PASSWORD: localdev
    volumes:
      - ./dev-init-scripts:/docker-entrypoint-initdb.d
    command: >
      -c log_statement=all
      -c log_min_duration_statement=0

# ბაზის განთავსების Argo CD აპლიკაციის მაგალითი
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: postgres-database
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/myorg/database-configs.git
    targetRevision: HEAD
    path: postgres
  destination:
    server: https://kubernetes.default.svc
    namespace: database
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true