Benchmark: yaml parsers benchmark

HTML Preparation code:

<script src="https://unpkg.com/yamljs/dist/yaml.min.js"></script>
<script>
    window.YAML1 = YAML
</script>
<script src="https://unpkg.com/js-yaml/dist/js-yaml.min.js"></script>
<script src="https://eemeli.org/yaml-playground/yaml.browser.js"></script>
<script>
    window.YAML2 = YAML
</script>

Script Preparation code:

var yamlString = `version: "3.9"

services:
  redis:
    image: "redis:7-alpine"
    container_name: "redis"
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - ./data/redis:/data
    networks:
      - backend

  db:
    image: "postgres:16"
    container_name: "db"
    restart: always
    environment:
      - POSTGRES_USER=admin
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=app
    ports:
      - "5432:5432"
    volumes:
      - ./data/db:/var/lib/postgresql/data
    networks:
      - backend

  app0:
    image: "example/app:0.0"
    container_name: "app0"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=0
      - LOG_LEVEL=info
    ports:
      - "8000:8080"
    volumes:
      - ./data/app0:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app1:
    image: "example/app:1.0"
    container_name: "app1"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=1
      - LOG_LEVEL=info
    ports:
      - "8001:8080"
    volumes:
      - ./data/app1:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app2:
    image: "example/app:2.0"
    container_name: "app2"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=2
      - LOG_LEVEL=info
    ports:
      - "8002:8080"
    volumes:
      - ./data/app2:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app3:
    image: "example/app:3.0"
    container_name: "app3"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=3
      - LOG_LEVEL=info
    ports:
      - "8003:8080"
    volumes:
      - ./data/app3:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app4:
    image: "example/app:4.0"
    container_name: "app4"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=4
      - LOG_LEVEL=info
    ports:
      - "8004:8080"
    volumes:
      - ./data/app4:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app5:
    image: "example/app:5.0"
    container_name: "app5"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=5
      - LOG_LEVEL=info
    ports:
      - "8005:8080"
    volumes:
      - ./data/app5:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app6:
    image: "example/app:6.0"
    container_name: "app6"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=6
      - LOG_LEVEL=info
    ports:
      - "8006:8080"
    volumes:
      - ./data/app6:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app7:
    image: "example/app:7.0"
    container_name: "app7"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=7
      - LOG_LEVEL=info
    ports:
      - "8007:8080"
    volumes:
      - ./data/app7:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app8:
    image: "example/app:8.0"
    container_name: "app8"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=8
      - LOG_LEVEL=info
    ports:
      - "8008:8080"
    volumes:
      - ./data/app8:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app9:
    image: "example/app:9.0"
    container_name: "app9"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=9
      - LOG_LEVEL=info
    ports:
      - "8009:8080"
    volumes:
      - ./data/app9:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app10:
    image: "example/app:0.0"
    container_name: "app10"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=10
      - LOG_LEVEL=info
    ports:
      - "8010:8080"
    volumes:
      - ./data/app10:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app11:
    image: "example/app:1.0"
    container_name: "app11"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=11
      - LOG_LEVEL=info
    ports:
      - "8011:8080"
    volumes:
      - ./data/app11:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app12:
    image: "example/app:2.0"
    container_name: "app12"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=12
      - LOG_LEVEL=info
    ports:
      - "8012:8080"
    volumes:
      - ./data/app12:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app13:
    image: "example/app:3.0"
    container_name: "app13"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=13
      - LOG_LEVEL=info
    ports:
      - "8013:8080"
    volumes:
      - ./data/app13:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app14:
    image: "example/app:4.0"
    container_name: "app14"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=14
      - LOG_LEVEL=info
    ports:
      - "8014:8080"
    volumes:
      - ./data/app14:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app15:
    image: "example/app:5.0"
    container_name: "app15"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=15
      - LOG_LEVEL=info
    ports:
      - "8015:8080"
    volumes:
      - ./data/app15:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app16:
    image: "example/app:6.0"
    container_name: "app16"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=16
      - LOG_LEVEL=info
    ports:
      - "8016:8080"
    volumes:
      - ./data/app16:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app17:
    image: "example/app:7.0"
    container_name: "app17"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=17
      - LOG_LEVEL=info
    ports:
      - "8017:8080"
    volumes:
      - ./data/app17:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app18:
    image: "example/app:8.0"
    container_name: "app18"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=18
      - LOG_LEVEL=info
    ports:
      - "8018:8080"
    volumes:
      - ./data/app18:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app19:
    image: "example/app:9.0"
    container_name: "app19"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=19
      - LOG_LEVEL=info
    ports:
      - "8019:8080"
    volumes:
      - ./data/app19:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app20:
    image: "example/app:0.0"
    container_name: "app20"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=20
      - LOG_LEVEL=info
    ports:
      - "8020:8080"
    volumes:
      - ./data/app20:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app21:
    image: "example/app:1.0"
    container_name: "app21"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=21
      - LOG_LEVEL=info
    ports:
      - "8021:8080"
    volumes:
      - ./data/app21:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app22:
    image: "example/app:2.0"
    container_name: "app22"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=22
      - LOG_LEVEL=info
    ports:
      - "8022:8080"
    volumes:
      - ./data/app22:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app23:
    image: "example/app:3.0"
    container_name: "app23"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=23
      - LOG_LEVEL=info
    ports:
      - "8023:8080"
    volumes:
      - ./data/app23:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app24:
    image: "example/app:4.0"
    container_name: "app24"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=24
      - LOG_LEVEL=info
    ports:
      - "8024:8080"
    volumes:
      - ./data/app24:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app25:
    image: "example/app:5.0"
    container_name: "app25"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=25
      - LOG_LEVEL=info
    ports:
      - "8025:8080"
    volumes:
      - ./data/app25:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app26:
    image: "example/app:6.0"
    container_name: "app26"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=26
      - LOG_LEVEL=info
    ports:
      - "8026:8080"
    volumes:
      - ./data/app26:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app27:
    image: "example/app:7.0"
    container_name: "app27"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=27
      - LOG_LEVEL=info
    ports:
      - "8027:8080"
    volumes:
      - ./data/app27:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app28:
    image: "example/app:8.0"
    container_name: "app28"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=28
      - LOG_LEVEL=info
    ports:
      - "8028:8080"
    volumes:
      - ./data/app28:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app29:
    image: "example/app:9.0"
    container_name: "app29"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=29
      - LOG_LEVEL=info
    ports:
      - "8029:8080"
    volumes:
      - ./data/app29:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app30:
    image: "example/app:0.0"
    container_name: "app30"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=30
      - LOG_LEVEL=info
    ports:
      - "8030:8080"
    volumes:
      - ./data/app30:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app31:
    image: "example/app:1.0"
    container_name: "app31"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=31
      - LOG_LEVEL=info
    ports:
      - "8031:8080"
    volumes:
      - ./data/app31:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app32:
    image: "example/app:2.0"
    container_name: "app32"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=32
      - LOG_LEVEL=info
    ports:
      - "8032:8080"
    volumes:
      - ./data/app32:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app33:
    image: "example/app:3.0"
    container_name: "app33"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=33
      - LOG_LEVEL=info
    ports:
      - "8033:8080"
    volumes:
      - ./data/app33:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app34:
    image: "example/app:4.0"
    container_name: "app34"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=34
      - LOG_LEVEL=info
    ports:
      - "8034:8080"
    volumes:
      - ./data/app34:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app35:
    image: "example/app:5.0"
    container_name: "app35"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=35
      - LOG_LEVEL=info
    ports:
      - "8035:8080"
    volumes:
      - ./data/app35:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app36:
    image: "example/app:6.0"
    container_name: "app36"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=36
      - LOG_LEVEL=info
    ports:
      - "8036:8080"
    volumes:
      - ./data/app36:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app37:
    image: "example/app:7.0"
    container_name: "app37"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=37
      - LOG_LEVEL=info
    ports:
      - "8037:8080"
    volumes:
      - ./data/app37:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app38:
    image: "example/app:8.0"
    container_name: "app38"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=38
      - LOG_LEVEL=info
    ports:
      - "8038:8080"
    volumes:
      - ./data/app38:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app39:
    image: "example/app:9.0"
    container_name: "app39"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=39
      - LOG_LEVEL=info
    ports:
      - "8039:8080"
    volumes:
      - ./data/app39:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app40:
    image: "example/app:0.0"
    container_name: "app40"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=40
      - LOG_LEVEL=info
    ports:
      - "8040:8080"
    volumes:
      - ./data/app40:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app41:
    image: "example/app:1.0"
    container_name: "app41"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=41
      - LOG_LEVEL=info
    ports:
      - "8041:8080"
    volumes:
      - ./data/app41:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app42:
    image: "example/app:2.0"
    container_name: "app42"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=42
      - LOG_LEVEL=info
    ports:
      - "8042:8080"
    volumes:
      - ./data/app42:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app43:
    image: "example/app:3.0"
    container_name: "app43"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=43
      - LOG_LEVEL=info
    ports:
      - "8043:8080"
    volumes:
      - ./data/app43:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app44:
    image: "example/app:4.0"
    container_name: "app44"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=44
      - LOG_LEVEL=info
    ports:
      - "8044:8080"
    volumes:
      - ./data/app44:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app45:
    image: "example/app:5.0"
    container_name: "app45"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=45
      - LOG_LEVEL=info
    ports:
      - "8045:8080"
    volumes:
      - ./data/app45:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app46:
    image: "example/app:6.0"
    container_name: "app46"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=46
      - LOG_LEVEL=info
    ports:
      - "8046:8080"
    volumes:
      - ./data/app46:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app47:
    image: "example/app:7.0"
    container_name: "app47"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=47
      - LOG_LEVEL=info
    ports:
      - "8047:8080"
    volumes:
      - ./data/app47:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app48:
    image: "example/app:8.0"
    container_name: "app48"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=48
      - LOG_LEVEL=info
    ports:
      - "8048:8080"
    volumes:
      - ./data/app48:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app49:
    image: "example/app:9.0"
    container_name: "app49"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=49
      - LOG_LEVEL=info
    ports:
      - "8049:8080"
    volumes:
      - ./data/app49:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app50:
    image: "example/app:0.0"
    container_name: "app50"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=50
      - LOG_LEVEL=info
    ports:
      - "8050:8080"
    volumes:
      - ./data/app50:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app51:
    image: "example/app:1.0"
    container_name: "app51"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=51
      - LOG_LEVEL=info
    ports:
      - "8051:8080"
    volumes:
      - ./data/app51:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app52:
    image: "example/app:2.0"
    container_name: "app52"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=52
      - LOG_LEVEL=info
    ports:
      - "8052:8080"
    volumes:
      - ./data/app52:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app53:
    image: "example/app:3.0"
    container_name: "app53"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=53
      - LOG_LEVEL=info
    ports:
      - "8053:8080"
    volumes:
      - ./data/app53:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app54:
    image: "example/app:4.0"
    container_name: "app54"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=54
      - LOG_LEVEL=info
    ports:
      - "8054:8080"
    volumes:
      - ./data/app54:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app55:
    image: "example/app:5.0"
    container_name: "app55"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=55
      - LOG_LEVEL=info
    ports:
      - "8055:8080"
    volumes:
      - ./data/app55:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app56:
    image: "example/app:6.0"
    container_name: "app56"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=56
      - LOG_LEVEL=info
    ports:
      - "8056:8080"
    volumes:
      - ./data/app56:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app57:
    image: "example/app:7.0"
    container_name: "app57"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=57
      - LOG_LEVEL=info
    ports:
      - "8057:8080"
    volumes:
      - ./data/app57:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app58:
    image: "example/app:8.0"
    container_name: "app58"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=58
      - LOG_LEVEL=info
    ports:
      - "8058:8080"
    volumes:
      - ./data/app58:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app59:
    image: "example/app:9.0"
    container_name: "app59"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=59
      - LOG_LEVEL=info
    ports:
      - "8059:8080"
    volumes:
      - ./data/app59:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app60:
    image: "example/app:0.0"
    container_name: "app60"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=60
      - LOG_LEVEL=info
    ports:
      - "8060:8080"
    volumes:
      - ./data/app60:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app61:
    image: "example/app:1.0"
    container_name: "app61"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=61
      - LOG_LEVEL=info
    ports:
      - "8061:8080"
    volumes:
      - ./data/app61:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app62:
    image: "example/app:2.0"
    container_name: "app62"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=62
      - LOG_LEVEL=info
    ports:
      - "8062:8080"
    volumes:
      - ./data/app62:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app63:
    image: "example/app:3.0"
    container_name: "app63"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=63
      - LOG_LEVEL=info
    ports:
      - "8063:8080"
    volumes:
      - ./data/app63:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app64:
    image: "example/app:4.0"
    container_name: "app64"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=64
      - LOG_LEVEL=info
    ports:
      - "8064:8080"
    volumes:
      - ./data/app64:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app65:
    image: "example/app:5.0"
    container_name: "app65"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=65
      - LOG_LEVEL=info
    ports:
      - "8065:8080"
    volumes:
      - ./data/app65:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app66:
    image: "example/app:6.0"
    container_name: "app66"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=66
      - LOG_LEVEL=info
    ports:
      - "8066:8080"
    volumes:
      - ./data/app66:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app67:
    image: "example/app:7.0"
    container_name: "app67"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=67
      - LOG_LEVEL=info
    ports:
      - "8067:8080"
    volumes:
      - ./data/app67:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app68:
    image: "example/app:8.0"
    container_name: "app68"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=68
      - LOG_LEVEL=info
    ports:
      - "8068:8080"
    volumes:
      - ./data/app68:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app69:
    image: "example/app:9.0"
    container_name: "app69"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=69
      - LOG_LEVEL=info
    ports:
      - "8069:8080"
    volumes:
      - ./data/app69:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app70:
    image: "example/app:0.0"
    container_name: "app70"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=70
      - LOG_LEVEL=info
    ports:
      - "8070:8080"
    volumes:
      - ./data/app70:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app71:
    image: "example/app:1.0"
    container_name: "app71"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=71
      - LOG_LEVEL=info
    ports:
      - "8071:8080"
    volumes:
      - ./data/app71:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app72:
    image: "example/app:2.0"
    container_name: "app72"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=72
      - LOG_LEVEL=info
    ports:
      - "8072:8080"
    volumes:
      - ./data/app72:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app73:
    image: "example/app:3.0"
    container_name: "app73"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=73
      - LOG_LEVEL=info
    ports:
      - "8073:8080"
    volumes:
      - ./data/app73:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app74:
    image: "example/app:4.0"
    container_name: "app74"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=74
      - LOG_LEVEL=info
    ports:
      - "8074:8080"
    volumes:
      - ./data/app74:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app75:
    image: "example/app:5.0"
    container_name: "app75"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=75
      - LOG_LEVEL=info
    ports:
      - "8075:8080"
    volumes:
      - ./data/app75:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app76:
    image: "example/app:6.0"
    container_name: "app76"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=76
      - LOG_LEVEL=info
    ports:
      - "8076:8080"
    volumes:
      - ./data/app76:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app77:
    image: "example/app:7.0"
    container_name: "app77"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=77
      - LOG_LEVEL=info
    ports:
      - "8077:8080"
    volumes:
      - ./data/app77:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app78:
    image: "example/app:8.0"
    container_name: "app78"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=78
      - LOG_LEVEL=info
    ports:
      - "8078:8080"
    volumes:
      - ./data/app78:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app79:
    image: "example/app:9.0"
    container_name: "app79"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=79
      - LOG_LEVEL=info
    ports:
      - "8079:8080"
    volumes:
      - ./data/app79:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app80:
    image: "example/app:0.0"
    container_name: "app80"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=80
      - LOG_LEVEL=info
    ports:
      - "8080:8080"
    volumes:
      - ./data/app80:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app81:
    image: "example/app:1.0"
    container_name: "app81"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=81
      - LOG_LEVEL=info
    ports:
      - "8081:8080"
    volumes:
      - ./data/app81:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app82:
    image: "example/app:2.0"
    container_name: "app82"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=82
      - LOG_LEVEL=info
    ports:
      - "8082:8080"
    volumes:
      - ./data/app82:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app83:
    image: "example/app:3.0"
    container_name: "app83"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=83
      - LOG_LEVEL=info
    ports:
      - "8083:8080"
    volumes:
      - ./data/app83:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app84:
    image: "example/app:4.0"
    container_name: "app84"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=84
      - LOG_LEVEL=info
    ports:
      - "8084:8080"
    volumes:
      - ./data/app84:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app85:
    image: "example/app:5.0"
    container_name: "app85"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=85
      - LOG_LEVEL=info
    ports:
      - "8085:8080"
    volumes:
      - ./data/app85:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app86:
    image: "example/app:6.0"
    container_name: "app86"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=86
      - LOG_LEVEL=info
    ports:
      - "8086:8080"
    volumes:
      - ./data/app86:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app87:
    image: "example/app:7.0"
    container_name: "app87"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=87
      - LOG_LEVEL=info
    ports:
      - "8087:8080"
    volumes:
      - ./data/app87:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app88:
    image: "example/app:8.0"
    container_name: "app88"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=88
      - LOG_LEVEL=info
    ports:
      - "8088:8080"
    volumes:
      - ./data/app88:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app89:
    image: "example/app:9.0"
    container_name: "app89"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=89
      - LOG_LEVEL=info
    ports:
      - "8089:8080"
    volumes:
      - ./data/app89:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app90:
    image: "example/app:0.0"
    container_name: "app90"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=90
      - LOG_LEVEL=info
    ports:
      - "8090:8080"
    volumes:
      - ./data/app90:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app91:
    image: "example/app:1.0"
    container_name: "app91"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=91
      - LOG_LEVEL=info
    ports:
      - "8091:8080"
    volumes:
      - ./data/app91:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app92:
    image: "example/app:2.0"
    container_name: "app92"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=92
      - LOG_LEVEL=info
    ports:
      - "8092:8080"
    volumes:
      - ./data/app92:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app93:
    image: "example/app:3.0"
    container_name: "app93"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=93
      - LOG_LEVEL=info
    ports:
      - "8093:8080"
    volumes:
      - ./data/app93:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app94:
    image: "example/app:4.0"
    container_name: "app94"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=94
      - LOG_LEVEL=info
    ports:
      - "8094:8080"
    volumes:
      - ./data/app94:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app95:
    image: "example/app:5.0"
    container_name: "app95"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=95
      - LOG_LEVEL=info
    ports:
      - "8095:8080"
    volumes:
      - ./data/app95:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app96:
    image: "example/app:6.0"
    container_name: "app96"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=96
      - LOG_LEVEL=info
    ports:
      - "8096:8080"
    volumes:
      - ./data/app96:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app97:
    image: "example/app:7.0"
    container_name: "app97"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=97
      - LOG_LEVEL=info
    ports:
      - "8097:8080"
    volumes:
      - ./data/app97:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app98:
    image: "example/app:8.0"
    container_name: "app98"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=98
      - LOG_LEVEL=info
    ports:
      - "8098:8080"
    volumes:
      - ./data/app98:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app99:
    image: "example/app:9.0"
    container_name: "app99"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=99
      - LOG_LEVEL=info
    ports:
      - "8099:8080"
    volumes:
      - ./data/app99:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app100:
    image: "example/app:0.0"
    container_name: "app100"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=100
      - LOG_LEVEL=info
    ports:
      - "8100:8080"
    volumes:
      - ./data/app100:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app101:
    image: "example/app:1.0"
    container_name: "app101"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=101
      - LOG_LEVEL=info
    ports:
      - "8101:8080"
    volumes:
      - ./data/app101:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app102:
    image: "example/app:2.0"
    container_name: "app102"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=102
      - LOG_LEVEL=info
    ports:
      - "8102:8080"
    volumes:
      - ./data/app102:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app103:
    image: "example/app:3.0"
    container_name: "app103"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=103
      - LOG_LEVEL=info
    ports:
      - "8103:8080"
    volumes:
      - ./data/app103:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app104:
    image: "example/app:4.0"
    container_name: "app104"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=104
      - LOG_LEVEL=info
    ports:
      - "8104:8080"
    volumes:
      - ./data/app104:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app105:
    image: "example/app:5.0"
    container_name: "app105"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=105
      - LOG_LEVEL=info
    ports:
      - "8105:8080"
    volumes:
      - ./data/app105:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app106:
    image: "example/app:6.0"
    container_name: "app106"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=106
      - LOG_LEVEL=info
    ports:
      - "8106:8080"
    volumes:
      - ./data/app106:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app107:
    image: "example/app:7.0"
    container_name: "app107"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=107
      - LOG_LEVEL=info
    ports:
      - "8107:8080"
    volumes:
      - ./data/app107:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app108:
    image: "example/app:8.0"
    container_name: "app108"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=108
      - LOG_LEVEL=info
    ports:
      - "8108:8080"
    volumes:
      - ./data/app108:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app109:
    image: "example/app:9.0"
    container_name: "app109"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=109
      - LOG_LEVEL=info
    ports:
      - "8109:8080"
    volumes:
      - ./data/app109:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app110:
    image: "example/app:0.0"
    container_name: "app110"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=110
      - LOG_LEVEL=info
    ports:
      - "8110:8080"
    volumes:
      - ./data/app110:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app111:
    image: "example/app:1.0"
    container_name: "app111"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=111
      - LOG_LEVEL=info
    ports:
      - "8111:8080"
    volumes:
      - ./data/app111:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app112:
    image: "example/app:2.0"
    container_name: "app112"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=112
      - LOG_LEVEL=info
    ports:
      - "8112:8080"
    volumes:
      - ./data/app112:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app113:
    image: "example/app:3.0"
    container_name: "app113"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=113
      - LOG_LEVEL=info
    ports:
      - "8113:8080"
    volumes:
      - ./data/app113:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app114:
    image: "example/app:4.0"
    container_name: "app114"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=114
      - LOG_LEVEL=info
    ports:
      - "8114:8080"
    volumes:
      - ./data/app114:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app115:
    image: "example/app:5.0"
    container_name: "app115"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=115
      - LOG_LEVEL=info
    ports:
      - "8115:8080"
    volumes:
      - ./data/app115:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app116:
    image: "example/app:6.0"
    container_name: "app116"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=116
      - LOG_LEVEL=info
    ports:
      - "8116:8080"
    volumes:
      - ./data/app116:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app117:
    image: "example/app:7.0"
    container_name: "app117"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=117
      - LOG_LEVEL=info
    ports:
      - "8117:8080"
    volumes:
      - ./data/app117:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app118:
    image: "example/app:8.0"
    container_name: "app118"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=118
      - LOG_LEVEL=info
    ports:
      - "8118:8080"
    volumes:
      - ./data/app118:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app119:
    image: "example/app:9.0"
    container_name: "app119"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=119
      - LOG_LEVEL=info
    ports:
      - "8119:8080"
    volumes:
      - ./data/app119:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app120:
    image: "example/app:0.0"
    container_name: "app120"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=120
      - LOG_LEVEL=info
    ports:
      - "8120:8080"
    volumes:
      - ./data/app120:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app121:
    image: "example/app:1.0"
    container_name: "app121"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=121
      - LOG_LEVEL=info
    ports:
      - "8121:8080"
    volumes:
      - ./data/app121:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app122:
    image: "example/app:2.0"
    container_name: "app122"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=122
      - LOG_LEVEL=info
    ports:
      - "8122:8080"
    volumes:
      - ./data/app122:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app123:
    image: "example/app:3.0"
    container_name: "app123"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=123
      - LOG_LEVEL=info
    ports:
      - "8123:8080"
    volumes:
      - ./data/app123:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app124:
    image: "example/app:4.0"
    container_name: "app124"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=124
      - LOG_LEVEL=info
    ports:
      - "8124:8080"
    volumes:
      - ./data/app124:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app125:
    image: "example/app:5.0"
    container_name: "app125"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=125
      - LOG_LEVEL=info
    ports:
      - "8125:8080"
    volumes:
      - ./data/app125:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app126:
    image: "example/app:6.0"
    container_name: "app126"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=126
      - LOG_LEVEL=info
    ports:
      - "8126:8080"
    volumes:
      - ./data/app126:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app127:
    image: "example/app:7.0"
    container_name: "app127"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=127
      - LOG_LEVEL=info
    ports:
      - "8127:8080"
    volumes:
      - ./data/app127:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app128:
    image: "example/app:8.0"
    container_name: "app128"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=128
      - LOG_LEVEL=info
    ports:
      - "8128:8080"
    volumes:
      - ./data/app128:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app129:
    image: "example/app:9.0"
    container_name: "app129"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=129
      - LOG_LEVEL=info
    ports:
      - "8129:8080"
    volumes:
      - ./data/app129:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app130:
    image: "example/app:0.0"
    container_name: "app130"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=130
      - LOG_LEVEL=info
    ports:
      - "8130:8080"
    volumes:
      - ./data/app130:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app131:
    image: "example/app:1.0"
    container_name: "app131"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=131
      - LOG_LEVEL=info
    ports:
      - "8131:8080"
    volumes:
      - ./data/app131:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app132:
    image: "example/app:2.0"
    container_name: "app132"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=132
      - LOG_LEVEL=info
    ports:
      - "8132:8080"
    volumes:
      - ./data/app132:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app133:
    image: "example/app:3.0"
    container_name: "app133"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=133
      - LOG_LEVEL=info
    ports:
      - "8133:8080"
    volumes:
      - ./data/app133:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app134:
    image: "example/app:4.0"
    container_name: "app134"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=134
      - LOG_LEVEL=info
    ports:
      - "8134:8080"
    volumes:
      - ./data/app134:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app135:
    image: "example/app:5.0"
    container_name: "app135"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=135
      - LOG_LEVEL=info
    ports:
      - "8135:8080"
    volumes:
      - ./data/app135:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app136:
    image: "example/app:6.0"
    container_name: "app136"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=136
      - LOG_LEVEL=info
    ports:
      - "8136:8080"
    volumes:
      - ./data/app136:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app137:
    image: "example/app:7.0"
    container_name: "app137"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=137
      - LOG_LEVEL=info
    ports:
      - "8137:8080"
    volumes:
      - ./data/app137:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app138:
    image: "example/app:8.0"
    container_name: "app138"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=138
      - LOG_LEVEL=info
    ports:
      - "8138:8080"
    volumes:
      - ./data/app138:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app139:
    image: "example/app:9.0"
    container_name: "app139"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=139
      - LOG_LEVEL=info
    ports:
      - "8139:8080"
    volumes:
      - ./data/app139:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app140:
    image: "example/app:0.0"
    container_name: "app140"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=140
      - LOG_LEVEL=info
    ports:
      - "8140:8080"
    volumes:
      - ./data/app140:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app141:
    image: "example/app:1.0"
    container_name: "app141"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=141
      - LOG_LEVEL=info
    ports:
      - "8141:8080"
    volumes:
      - ./data/app141:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app142:
    image: "example/app:2.0"
    container_name: "app142"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=142
      - LOG_LEVEL=info
    ports:
      - "8142:8080"
    volumes:
      - ./data/app142:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app143:
    image: "example/app:3.0"
    container_name: "app143"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=143
      - LOG_LEVEL=info
    ports:
      - "8143:8080"
    volumes:
      - ./data/app143:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app144:
    image: "example/app:4.0"
    container_name: "app144"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=144
      - LOG_LEVEL=info
    ports:
      - "8144:8080"
    volumes:
      - ./data/app144:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app145:
    image: "example/app:5.0"
    container_name: "app145"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=145
      - LOG_LEVEL=info
    ports:
      - "8145:8080"
    volumes:
      - ./data/app145:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app146:
    image: "example/app:6.0"
    container_name: "app146"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=146
      - LOG_LEVEL=info
    ports:
      - "8146:8080"
    volumes:
      - ./data/app146:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app147:
    image: "example/app:7.0"
    container_name: "app147"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=147
      - LOG_LEVEL=info
    ports:
      - "8147:8080"
    volumes:
      - ./data/app147:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app148:
    image: "example/app:8.0"
    container_name: "app148"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=148
      - LOG_LEVEL=info
    ports:
      - "8148:8080"
    volumes:
      - ./data/app148:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app149:
    image: "example/app:9.0"
    container_name: "app149"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=149
      - LOG_LEVEL=info
    ports:
      - "8149:8080"
    volumes:
      - ./data/app149:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app150:
    image: "example/app:0.0"
    container_name: "app150"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=150
      - LOG_LEVEL=info
    ports:
      - "8150:8080"
    volumes:
      - ./data/app150:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app151:
    image: "example/app:1.0"
    container_name: "app151"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=151
      - LOG_LEVEL=info
    ports:
      - "8151:8080"
    volumes:
      - ./data/app151:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app152:
    image: "example/app:2.0"
    container_name: "app152"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=152
      - LOG_LEVEL=info
    ports:
      - "8152:8080"
    volumes:
      - ./data/app152:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app153:
    image: "example/app:3.0"
    container_name: "app153"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=153
      - LOG_LEVEL=info
    ports:
      - "8153:8080"
    volumes:
      - ./data/app153:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app154:
    image: "example/app:4.0"
    container_name: "app154"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=154
      - LOG_LEVEL=info
    ports:
      - "8154:8080"
    volumes:
      - ./data/app154:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app155:
    image: "example/app:5.0"
    container_name: "app155"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=155
      - LOG_LEVEL=info
    ports:
      - "8155:8080"
    volumes:
      - ./data/app155:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app156:
    image: "example/app:6.0"
    container_name: "app156"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=156
      - LOG_LEVEL=info
    ports:
      - "8156:8080"
    volumes:
      - ./data/app156:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app157:
    image: "example/app:7.0"
    container_name: "app157"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=157
      - LOG_LEVEL=info
    ports:
      - "8157:8080"
    volumes:
      - ./data/app157:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app158:
    image: "example/app:8.0"
    container_name: "app158"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=158
      - LOG_LEVEL=info
    ports:
      - "8158:8080"
    volumes:
      - ./data/app158:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app159:
    image: "example/app:9.0"
    container_name: "app159"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=159
      - LOG_LEVEL=info
    ports:
      - "8159:8080"
    volumes:
      - ./data/app159:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app160:
    image: "example/app:0.0"
    container_name: "app160"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=160
      - LOG_LEVEL=info
    ports:
      - "8160:8080"
    volumes:
      - ./data/app160:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app161:
    image: "example/app:1.0"
    container_name: "app161"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=161
      - LOG_LEVEL=info
    ports:
      - "8161:8080"
    volumes:
      - ./data/app161:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app162:
    image: "example/app:2.0"
    container_name: "app162"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=162
      - LOG_LEVEL=info
    ports:
      - "8162:8080"
    volumes:
      - ./data/app162:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app163:
    image: "example/app:3.0"
    container_name: "app163"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=163
      - LOG_LEVEL=info
    ports:
      - "8163:8080"
    volumes:
      - ./data/app163:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app164:
    image: "example/app:4.0"
    container_name: "app164"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=164
      - LOG_LEVEL=info
    ports:
      - "8164:8080"
    volumes:
      - ./data/app164:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app165:
    image: "example/app:5.0"
    container_name: "app165"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=165
      - LOG_LEVEL=info
    ports:
      - "8165:8080"
    volumes:
      - ./data/app165:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app166:
    image: "example/app:6.0"
    container_name: "app166"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=166
      - LOG_LEVEL=info
    ports:
      - "8166:8080"
    volumes:
      - ./data/app166:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app167:
    image: "example/app:7.0"
    container_name: "app167"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=167
      - LOG_LEVEL=info
    ports:
      - "8167:8080"
    volumes:
      - ./data/app167:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app168:
    image: "example/app:8.0"
    container_name: "app168"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=168
      - LOG_LEVEL=info
    ports:
      - "8168:8080"
    volumes:
      - ./data/app168:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app169:
    image: "example/app:9.0"
    container_name: "app169"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=169
      - LOG_LEVEL=info
    ports:
      - "8169:8080"
    volumes:
      - ./data/app169:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app170:
    image: "example/app:0.0"
    container_name: "app170"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=170
      - LOG_LEVEL=info
    ports:
      - "8170:8080"
    volumes:
      - ./data/app170:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app171:
    image: "example/app:1.0"
    container_name: "app171"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=171
      - LOG_LEVEL=info
    ports:
      - "8171:8080"
    volumes:
      - ./data/app171:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app172:
    image: "example/app:2.0"
    container_name: "app172"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=172
      - LOG_LEVEL=info
    ports:
      - "8172:8080"
    volumes:
      - ./data/app172:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app173:
    image: "example/app:3.0"
    container_name: "app173"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=173
      - LOG_LEVEL=info
    ports:
      - "8173:8080"
    volumes:
      - ./data/app173:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app174:
    image: "example/app:4.0"
    container_name: "app174"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=174
      - LOG_LEVEL=info
    ports:
      - "8174:8080"
    volumes:
      - ./data/app174:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app175:
    image: "example/app:5.0"
    container_name: "app175"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=175
      - LOG_LEVEL=info
    ports:
      - "8175:8080"
    volumes:
      - ./data/app175:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app176:
    image: "example/app:6.0"
    container_name: "app176"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=176
      - LOG_LEVEL=info
    ports:
      - "8176:8080"
    volumes:
      - ./data/app176:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app177:
    image: "example/app:7.0"
    container_name: "app177"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=177
      - LOG_LEVEL=info
    ports:
      - "8177:8080"
    volumes:
      - ./data/app177:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app178:
    image: "example/app:8.0"
    container_name: "app178"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=178
      - LOG_LEVEL=info
    ports:
      - "8178:8080"
    volumes:
      - ./data/app178:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app179:
    image: "example/app:9.0"
    container_name: "app179"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=179
      - LOG_LEVEL=info
    ports:
      - "8179:8080"
    volumes:
      - ./data/app179:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app180:
    image: "example/app:0.0"
    container_name: "app180"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=180
      - LOG_LEVEL=info
    ports:
      - "8180:8080"
    volumes:
      - ./data/app180:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app181:
    image: "example/app:1.0"
    container_name: "app181"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=181
      - LOG_LEVEL=info
    ports:
      - "8181:8080"
    volumes:
      - ./data/app181:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app182:
    image: "example/app:2.0"
    container_name: "app182"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=182
      - LOG_LEVEL=info
    ports:
      - "8182:8080"
    volumes:
      - ./data/app182:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app183:
    image: "example/app:3.0"
    container_name: "app183"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=183
      - LOG_LEVEL=info
    ports:
      - "8183:8080"
    volumes:
      - ./data/app183:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app184:
    image: "example/app:4.0"
    container_name: "app184"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=184
      - LOG_LEVEL=info
    ports:
      - "8184:8080"
    volumes:
      - ./data/app184:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app185:
    image: "example/app:5.0"
    container_name: "app185"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=185
      - LOG_LEVEL=info
    ports:
      - "8185:8080"
    volumes:
      - ./data/app185:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app186:
    image: "example/app:6.0"
    container_name: "app186"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=186
      - LOG_LEVEL=info
    ports:
      - "8186:8080"
    volumes:
      - ./data/app186:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app187:
    image: "example/app:7.0"
    container_name: "app187"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=187
      - LOG_LEVEL=info
    ports:
      - "8187:8080"
    volumes:
      - ./data/app187:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app188:
    image: "example/app:8.0"
    container_name: "app188"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=188
      - LOG_LEVEL=info
    ports:
      - "8188:8080"
    volumes:
      - ./data/app188:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app189:
    image: "example/app:9.0"
    container_name: "app189"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=189
      - LOG_LEVEL=info
    ports:
      - "8189:8080"
    volumes:
      - ./data/app189:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app190:
    image: "example/app:0.0"
    container_name: "app190"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=190
      - LOG_LEVEL=info
    ports:
      - "8190:8080"
    volumes:
      - ./data/app190:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app191:
    image: "example/app:1.0"
    container_name: "app191"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=191
      - LOG_LEVEL=info
    ports:
      - "8191:8080"
    volumes:
      - ./data/app191:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app192:
    image: "example/app:2.0"
    container_name: "app192"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=192
      - LOG_LEVEL=info
    ports:
      - "8192:8080"
    volumes:
      - ./data/app192:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app193:
    image: "example/app:3.0"
    container_name: "app193"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=193
      - LOG_LEVEL=info
    ports:
      - "8193:8080"
    volumes:
      - ./data/app193:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app194:
    image: "example/app:4.0"
    container_name: "app194"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=194
      - LOG_LEVEL=info
    ports:
      - "8194:8080"
    volumes:
      - ./data/app194:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app195:
    image: "example/app:5.0"
    container_name: "app195"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=195
      - LOG_LEVEL=info
    ports:
      - "8195:8080"
    volumes:
      - ./data/app195:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app196:
    image: "example/app:6.0"
    container_name: "app196"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=196
      - LOG_LEVEL=info
    ports:
      - "8196:8080"
    volumes:
      - ./data/app196:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app197:
    image: "example/app:7.0"
    container_name: "app197"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=197
      - LOG_LEVEL=info
    ports:
      - "8197:8080"
    volumes:
      - ./data/app197:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app198:
    image: "example/app:8.0"
    container_name: "app198"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=198
      - LOG_LEVEL=info
    ports:
      - "8198:8080"
    volumes:
      - ./data/app198:/var/lib/app
    networks:
      - backend
    depends_on:
      - redis
      - db

  app199:
    image: "example/app:9.0"
    container_name: "app199"
    restart: always
    environment:
      - NODE_ENV=production
      - SERVICE_ID=199
      - LOG_LEVEL=info
    ports:
      - "8199:8080"
    volumes:
      - ./data/app199:/var/lib/app
   `;

Tests:

yaml-js
var dummy = YAML1.parse(yamlString);
js-yaml
var dummy = jsyaml.load(yamlString);
yaml
var dummy = YAML2.parse(yamlString)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
yaml-js
js-yaml
yaml

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36

Browser/OS: Chrome 148 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
yaml-js	84.0 Ops/sec
js-yaml	422.4 Ops/sec
yaml	85.7 Ops/sec

Related benchmarks:

yaml parsers benchmark (version: 1)

Comparing performance of: yaml-js vs js-yaml vs yaml

Created: one month ago by: Registered User

Jump to the latest result

yaml-js

js-yaml

yaml

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A