Giga docker compose

@kimamila m’avait demandé de faire un giga docker compose avec tous les services :

J’ai donc réuni les différents docker compose en un seul :

# giga docker compose with a lot of services

services:
  # Duniter archive node used for squid indexing
  duniter-archive:
    image: duniter/duniter-v2s-gdev:latest
    restart: unless-stopped
    ports:
      # prometheus
      - 127.0.0.1:9615:9615
      # RPC API
      - 127.0.0.1:9944:9944
      # public p2p endpoint
      - 30333:30333
    volumes:
      - duniter-archive:/var/lib/duniter/
    environment:
      - DUNITER_CHAIN_NAME=gdev
      - DUNITER_NODE_NAME=${DUNITER_NODE_NAME}
      - DUNITER_PRUNING_PROFILE=archive
      - DUNITER_PUBLIC_ADDR=${DUNITER_PUBLIC_ADDR}
      - DUNITER_LISTEN_ADDR=/ip4/0.0.0.0/tcp/30333

  # squid processor 
  squid-processor:
    image: h30x/duniter-squid
    depends_on:
      squid-db:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "pgrep -f 'process:prod'"]
      interval: 5s
      timeout: 2s
      retries: 3
    environment:
      - DB_NAME=${SQUID_DB_NAME}
      - DB_PORT=5432
      - DB_HOST=squid-db
      - DB_PASS=${SQUID_DB_PASSWORD}
      - RPC_ENDPOINT=ws://duniter-archive:9944
      - GENESIS_FILE=${GENESIS_FILE}
      - HIST_BLOCK_FILE=${HIST_BLOCK_FILE}
      - HIST_TX_FILE=${HIST_TX_FILE}
      - HIST_CERT_FILE=${HIST_CERT_FILE}
    command: ["sqd", "process:prod"]

  # postgres database used by subsquid
  squid-db:
    image: postgres:15
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d ${DB_NAME}"]
      interval: 2s
      timeout: 2s
      retries: 5
    environment:
      POSTGRES_DB: ${DB_NAME}
      POSTGRES_PASSWORD: ${SQUID_DB_PASSWORD}

  # hasura endpoint of squid
  hasura-squid:
    image: h30x/duniter-squid-hasura:latest
    depends_on:
      processor:
        condition: service_healthy
    restart: always
    ports:
      - "127.0.0.1:4350:8080"
    environment:
      PRODUCTION: "true"
      HASURA_GRAPHQL_DATABASE_URL: postgres://postgres:${SQUID_DB_PASSWORD}@squid-db:5432/${SQUID_DB_NAME}
      HASURA_GRAPHQL_ENABLE_CONSOLE: "true"
      HASURA_GRAPHQL_DEV_MODE: "false"
      HASURA_GRAPHQL_UNAUTHORIZED_ROLE: public
      HASURA_GRAPHQL_ENABLE_TELEMETRY: "false"
      HASURA_GRAPHQL_ADMIN_SECRET: ${SQUID_HASURA_GRAPHQL_ADMIN_SECRET}

  # postgres database used by datapod
  postgres:
    image: postgres:16
    restart: always
    volumes:
      - db_data:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: ${DATAPOD_DB_USER}
      POSTGRES_PASSWORD: ${DATAPOD_DB_PASSWORD}
      POSTGRES_DB: ${DATAPOD_DB_DATABASE}
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DATAPOD_DB_USER} -d postgres"]
      interval: 1s

  # hasura instance used by datapod
  hasura:
    image: h30x/datapod-hasura
    depends_on:
      postgres:
        condition: service_healthy
    restart: always
    ports:
      - "127.0.0.1:${HASURA_LISTEN_PORT}:8080"
    environment:
      HASURA_GRAPHQL_DATABASE_URL: postgres://${DATAPOD_DB_USER}:${DATAPOD_DB_PASSWORD}@postgres:5432/${DATAPOD_DB_DATABASE}
      HASURA_GRAPHQL_ENABLE_CONSOLE: true
      HASURA_GRAPHQL_DEV_MODE: false
      HASURA_GRAPHQL_UNAUTHORIZED_ROLE: public
      HASURA_GRAPHQL_ENABLE_TELEMETRY: false
      HASURA_GRAPHQL_ADMIN_SECRET: ${HASURA_GRAPHQL_ADMIN_SECRET}

  # ipfs instance of datapod
  kubo:
    image: h30x/datapod-kubo
    ports:
      # p2p port public
      - 4001:4001
      - 4001:4001/udp
      # p2p through websocket
      - 127.0.0.1:4002:4002
      # public gateway
      - 127.0.0.1:${KUBO_GATEWAY_PORT}:8080
      - "[::1]:${KUBO_GATEWAY_PORT}:8080"
      # expose RPC locally to allow access with ssh tunnel
      - 127.0.0.1:5001:5001
    volumes:
      - kubo_data:/data/ipfs
      # optional volume if you want to persist the configuration script in order to change it
      # - kubo_init:/container-init.d
    environment:
      KUBO_DOMAIN: ${KUBO_DOMAIN}
      KUBO_WEBSOCKET_DOMAIN: ${KUBO_WEBSOCKET_DOMAIN}
      KUBO_GATEWAY_DOMAIN: ${KUBO_GATEWAY_DOMAIN}
      KUBO_GATEWAY_SUBDOMAIN: ${KUBO_GATEWAY_SUBDOMAIN}
    restart: always

  # optional kubo pubsub to see what the node receives on pubsub
  pubsub:
    image: ipfs/kubo:v0.28.0
    restart: always
    depends_on:
      kubo:
        condition: service_healthy
    entrypoint: "ipfs"
    command: ["--api=/dns/kubo/tcp/5001", "pubsub", "sub", "ddd"]

  # datapod processor
  datapod:
    image: h30x/duniter-datapod
    depends_on:
      postgres:
        condition: service_healthy
      kubo:
        condition: service_healthy
    environment:
      KUBO_RPC: "http://kubo:5001"
      DB_HOST: postgres
      DB_PORT: 5432
      DB_USER: ${DATAPOD_DB_USER}
      DB_PASSWORD: ${DATAPOD_DB_PASSWORD}
    restart: always
    # use the datapod collector and indexer, start using given IPNS entry
    command: ["./src/indexer/start.ts", "${DATAPOD_BOOT}"]

  # datapod http submit gateway
  gateway:
    image: h30x/duniter-datapod
    depends_on:
      kubo:
        condition: service_healthy
    ports:
      - ${SUBMIT_GATEWAY_LISTEN_PORT}:3000
    environment:
      KUBO_RPC: 'http://kubo:5001'
    restart: always
    command: ['./src/gateway/start.ts']


volumes:
  # duniter
  duniter-archive:
  # squid
  postgres-data:
  # datapod
  db_data:
  kubo_data:
  kubo_init:

Configurable avec les variables d’environnement

# Duniter part
DUNITER_NODE_NAME="hugo-gdev-archive"
DUNITER_PUBLIC_ADDR=/dns/gdev.coinduf.eu/tcp/30333


# squid part
SQUID_DB_NAME=squid
SQUID_DB_PASSWORD=postgres
SQUID_HASURA_GRAPHQL_ADMIN_SECRET=xxx
SQUID_HASURA_LISTEN_PORT=8080

GENESIS_FILE="./input/gdev.json"
HIST_BLOCK_FILE="./input/block_hist.json"
HIST_TX_FILE="./input/tx_hist.json"
HIST_CERT_FILE="./input/cert_hist.json"

# datapod part
DATAPOD_DB_USER=postgres
DATAPOD_DB_PASSWORD=postgrespassword
DATAPOD_DB_DATABASE=postgres
DATAPOD_HASURA_LISTEN_PORT=8765
DATAPOD_HASURA_GRAPHQL_ADMIN_SECRET=xxx
KUBO_GATEWAY_PORT=7654
KUBO_DOMAIN=datapod.coinduf.eu
KUBO_WEBSOCKET_DOMAIN=websocket.datapod.coinduf.eu
KUBO_GATEWAY_DOMAIN=gateway.datapod.coinduf.eu
KUBO_GATEWAY_SUBDOMAIN=pagu.re
SUBMIT_GATEWAY_LISTEN_PORT=7777

# configure the node boot
DATAPOD_BOOT=bafyreih4jspnqnsd4o3sdqv7c765uyylhtlh5majjw6aq6clilkq7tmqey

Mais je n’ai pas testé, et il y a probablement des conflits de port (par exemple le 8080 pour hasura et pour la gateway ipfs).

En fait :

  • Je ne vois pas l’intérêt de faire ça, docker est justement prévu pour faire de l’isolation, et là on fait tout l’inverse en fusionnant tous les réseaux, ce qui fait apparaître des problèmes de conflits de port par exemple.
  • Ce n’est ni évident ni une bonne idée d’utiliser la même db pour subsquid et pour les datapods, parce que ça complique la réinitialisation de l’un sans l’autre. Si c’est séparé il suffit de supprimer les volumes, mais ça ne marche plus si c’est réuni.
  • Même si j’ai pas mal progressé depuis Difficultés avec l'outillage (novembre 2022) et 🛟 Je galère une fois de plus sur la mise en prod (novembre 2023), l’admin sys n’est toujours pas mon métier, je ne suis pas à l’aise, j’aurais besoin que quelqu’un de compétent prenne le relais sur ces points parce que je sens que c’est bloquant pour l’adoption par les autres devs et les utilisateurs.

Par contre :

  • Je vois certains trucs qui ne sont plus à jour (non bloquants), notamment au niveau de la documentation, je vais faire une passe.
  • Il y a des choses à améliorer et harmoniser sur la gestion des variables d’environnement, je vais le faire.
  • Il faudrait également une config nginx d’exemple complète pour mettre ça en prod.

Donc j’aurais besoin que tu précises ton besoin @kimamila. Est-ce que l’idée était d’avoir une stack en local pour bosser sur la gdev ? Est-ce que tu voulais mettre en production des instances pour maîtriser tes endpoints ?