Guia de Instalação

O sistema é composto por vários módulos que são tipicamente executados em containers Docker. Eles são:

• API Service: contém a API REST para a execução do processo de transcrição e gerenciamento dos arquivos de áudio.
• DB Watcher: realiza a leitura dos arquivos de áudio a serem transcritos e distribui a carga de processamento para os executores do processo de transcrição.
• Normalization Executor: executor da etapa de normalização de arquivo de áudio.
• Diarization Executor: executor da etapa de diarização de arquivo de áudio normalizado.
• Recognition Executor: executor da etapa de reconhecimento de fala de segmento de fala diarizado.

Adicionalmente, ele ainda conta com os seguintes elementos:

• MongoDB: banco de dados do sistema.
• RabbitMQ: message broker para distribuir a carga de trabalho entre o controle do processo e os executores.

A instalação típica do sistema em ambiente de produção organiza os módulos em dois tipos de servidores ou nós:

• Nó de Controle: contém os elementos mais leves do sistema, que normalmente não necessitam de escalabilidade, utiliza portanto poucos recursos de hardware. É formado pelos módulos:
  • API Service.
  • DB Watcher.
  • Normalization Executor.
  • MongoDB.
  • RabbitMQ.
• Nó de Processamento: contém os elementos que consomem uma maior quantidade de recursos de processamento. Possui maior necessidade de hardware e podem ser replicados para aumentar a capacidade do sistema. É formado por:
  • Diarization Executor.
  • Recognition Executor.

Requisitos de Instalação

Todas as máquinas devem possuir:

• Processadores da plataforma Intel Xeon ou família Core (5ª geração ou superior)
• Sistema operacional CentOS 7.5 x64
• Docker Compose e Docker Engine Community
• Filesystem compartilhado entre os Nós de Controle e Processamento

Para o Nó de Controle, recomenda-se a configuração:

• 4 vCPU; 8 GB RAM; 50 GB HD e 500 GB HD como disco de trabalho

Para as máquinas de Processamento, recomenda-se:

• 16 vCPU; 16 GB RAM; 50 GB HD

Procedimento de Instalação

1. Instalação do Docker

Siga os passos de instalação do Docker. Por exemplo, para sistema operacional Linux CentOS, o procedimento de instalação se encontra aqui.

2. Instalação do Docker Compose

Siga os passos de instalação do Docker compose.

Aviso

Para obter as imagens docker é necessario ter acesso à rede corporativa do CPqD e ao repositório cpqd-docker-dev. O download das imagens será feito nos passos adiante.

3. Criação da estrutura de diretório de trabalho

Nota

Esse procedimento assume que serão utilizado os discos /l/disk0 para persistência do banco de dados e /l/disk1 para armazenamento e processamento de arquivos de áudio. O disco /l/disk1 deve ser compartilhado entre as máquinas do sistema.

4. Na máquina do Nó de Controle execute os comandos descritos a seguir.

• Crie a pasta de trabalho no disco /l/disk1. Esse disco deve ser compartilhado com as máquinas do Nó de Processamento.

$ mkdir /l/disk1/transcription && \
  chmod 775 -R /l/disk1/transcription

• Crie a pasta de persistência para o MongoDB em /l/disk0/mongodb.

$ mkdir -p /l/disk0/mongodb && \
  chmod 775 -R /l/disk0/mongodb

• Crie o script de inicialização do Nó de Controle init_node_controller.sh e configure nele as variáveis de ambiente:

  • TRD_DATA: Diretório de trabalho, compartilhado entre todos nós (/l/disk1/transcription).
  • TRD_MONGODB: Diretório para persistência do MongoDB (/l/disk0/mongodb).

  #!/bin/bash
  ### Parâmetros que tipicamente serão alterados ###
  export TRD_DATA=/l/disk1/transcription
  export TRD_MONGODB=/l/disk0/mongodb
  export TRD_LOG=/var/log/cpqd/trd/
  
  ### Parâmetros que só serão alterados caso haja alguma mudança no setup padrão ###
  export SPRING_APP_JSON='{"transcription": {"profile": "prod", "directory": {"audio": "/home/transcription/audio", "upload": "/home/transcription/upload"}, "mongodb.uri": "mongodb://mongo:27017/test", "rabbitmq": {"user": "guest", "pwd": "guest", "host": "rabbitmq", "port": 5672}}}'
  export REDIS_HOST=redis-cache
  export TIMEZONE="America/Sao_Paulo"
  export VALID_EXTENSION_FORMATS='[".wav", ".mp3", ".flac", ".wma"]'
  export MAX_AUDIO_DURATION_SECS=3600     #1h
  export MAX_AUDIO_SIZE_BYTES=1073741824  #1Gbyte
  
  docker-compose -f docker-compose_nd_controller.yml up --scale node-manager=0 -d
  

• Crie o docker-compose a seguir:

  # Docker compose file for Production environment: Controller Node
  version: '3'
  
  services:
    mongo:
      image: mongo:4.1
      container_name: transcript-mongo
      restart: always
      environment:
        TZ: ${TIMEZONE}
      ports:
        - "27017:27017"
      volumes:
        - $TRD_MONGODB:/data/db
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "5"
  
    redis-cache:
      image: redis:5.0-alpine
      container_name: transcript-redis
      restart: always
      environment:
        TZ: ${TIMEZONE}
      logging:
        driver: "json-file"
        options:
          max-size: "2m"
          max-file: "2"
  
    dbwatcher:
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/dbwatcher:2.1.4
      container_name: transcript-dbwatcher
      restart: always
      environment:
        SPRING_APPLICATION_JSON: ${SPRING_APP_JSON}
        TZ: ${TIMEZONE}
      logging:
        driver: "json-file"
        options:
          max-size: "2m"
          max-file: "2"
      volumes:
        - $TRD_DATA:/home/transcription
  
    rabbitmq:
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/rabbitmq:2.1.4
      container_name: transcript-rabbit
      restart: always
      environment:
        TZ: ${TIMEZONE}
      ports:
        - "5672:5672"
        - "8072:15672"
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "5"
  
    transcription-api:
      container_name: transcript-api
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/transcription-api:2.1.4
      restart: always
      environment:
        SPRING_APPLICATION_JSON: ${SPRING_APP_JSON}
        VALID_EXTENSION_FORMATS: ${VALID_EXTENSION_FORMATS}
        MAX_AUDIO_DURATION_SECS: ${MAX_AUDIO_DURATION_SECS}
        MAX_AUDIO_SIZE_BYTES: ${MAX_AUDIO_SIZE_BYTES}
        TZ: ${TIMEZONE}
      ports:
        - "8080:8080"
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "5"
      volumes:
        - $TRD_DATA:/home/transcription
  
    transcription-dashboard:
      container_name: transcript-dashboard
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/transcription-dashboard:2.1.4
      restart: always
      environment:
        API_HOST: http://transcription-api
        API_PORT: 8080
        REDIS_HOST: redis-cache
        SPRING_APPLICATION_JSON: ${SPRING_APP_JSON}
        TZ: ${TIMEZONE}
      ports:
        - "8050:8050"
      logging:
        driver: "json-file"
        options:
         max-size: "2m"
         max-file: "2"
      volumes:
        - $TRD_DATA:/home/transcription
  
    transcription-pipeline:
      container_name: transcript-pipeline
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/transcription-pipeline:2.1.4
      restart: always
      environment:
        SPRING_APPLICATION_JSON: ${SPRING_APP_JSON}
        TZ: ${TIMEZONE}
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "5"
      volumes:
        - $TRD_DATA:/home/transcription
  
    normalization-executor:
      container_name: transcript-normalization
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/normalization-executor:2.1.4
      restart: always
      environment:
        SPRING_APPLICATION_JSON: ${SPRING_APP_JSON}
        TZ: ${TIMEZONE}
      ports:
        - "8082:8082"
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "5"
      volumes:
        - $TRD_DATA:/home/transcription
        - $TRD_LOG:/var/log/cpqd/trd/
  
  networks:
    default:
      driver: bridge
  

5. Nas máquinas do Nó de Processamento execute os comandos descritos a seguir.

• Crie a pasta de logs em /var/log/cpqd.

$ mkdir -p /var/log/cpqd && \
  chmod 775 -R /var/log/transcription

• Verifique se o compartilhamento das pastas de trabalho do Nó de Controle foi realizado em /l/disk1/transcription.

• Crie o script de inicialização do Nó de Processamento init_node_processor.sh e configure nele as variáveis de ambiente:

  • TRD_DATA: Diretório de trabalho, compartilhado entre todos nós (/l/disk1/transcription).
  • TRD_LOG: Diretório de logs (/var/log/cpqd).
  • LICENSE_HOST: Endereço do servidor de licença (license38.cpqd.com.br).
  • ASR_LICENSE_ID: ID da licença do Reconhecimento de fala, fornecido pelo CPqD.
  • ASR_LICENSE_CHANNELS: Número de canais do Reconhecimento de fala.
  • DIARIZATION_LICENSE_ID: ID da licença do Diarizador, fornecido pelo CPqD.
  • ND_CONTROL_HOST: Endereço do nó de controle.

  #!/bin/bash
  # Parâmetros que tipicamente serão alterados
  export LICENSE_HOST=license38.cpqd.com.br         # Trocar em caso de licenciamento local
  export ASR_LICENSE_ID=dummyasrid                  # ID da licença do ASR
  export ASR_LICENSE_CHANNELS=0                     # Número de canais desejados no nó
  export DIARIZATION_LICENSE_ID=dummydiarizationid  # ID da licença do diarizador
  ND_CONTROL_HOST=awsdsda000.cpqd.com.br            # Hostname do nó de controle
  
  export TRD_DATA=/l/disk1/transcription
  export TRD_LOG=/var/log/cpqd
  
  # Parâmetros que só serão alterados caso haja alguma mudança no setup padrão
  export SPRING_APP_JSON='{"transcription": {"profile": "prod", "directory": {"audio": "/home/transcription/audio", "upload": "/home/transcription/upload"}, "mongodb.uri": "mongodb://'${ND_CONTROL_HOST}':27017/test", "rabbitmq": {"user": "guest", "pwd": "guest", "host": "'${ND_CONTROL_HOST}'", "port": 5672}}}'
  
  export ASR_SERVER_URL=ws://asr-server:8025/asr-server/asr
  export ASR_LM_URI=builtin:slm/callcenter-small
  export TIMEZONE="America/Sao_Paulo"
  
  docker-compose -f docker-compose_nd_processor.yml up -d
  

• Crie o docker-compose a seguir:

  # Docker compose file for Production environment: Processor Node
  version: '3'
  
  services:
    diarization-executor:
      container_name: transcript-diarization
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/diarization-executor:2.1.4
      restart: always
      environment:
        SPRING_APPLICATION_JSON: ${SPRING_APP_JSON}
        DIARIZATION_LICENSE_HOST: ${LICENSE_HOST}
        DIARIZATION_LICENSE_ID: ${DIARIZATION_LICENSE_ID}
        TZ: ${TIMEZONE}
      logging:
        driver: "json-file"
        options:
          max-size: "2m"
          max-file: "2"
      volumes:
        - $TRD_DATA:/home/transcription
        - cache:/var/tmp
  
    recognition-executor:
      container_name: transcript-recognition
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/recognition-executor:2.1.4
      restart: always
      environment:
        SPRING_APPLICATION_JSON: ${SPRING_APP_JSON}
        ASR_LM_URI: ${ASR_LM_URI}
        ASR_SERVER_URL: ${ASR_SERVER_URL}
        ASR_LICENSE_CHANNELS: ${ASR_LICENSE_CHANNELS}
        TZ: ${TIMEZONE}
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "5"
  
    asr-server:
      container_name: transcript-asr
      image: artifactory.cpqd.com.br:8443/docker-dev/cpqd/trd/asr-server:2.1.4
      restart: always
      ports:
        - 8083:8081
      environment:
        ASR_LICENSE_HOST: ${LICENSE_HOST}
        ASR_LICENSE_ID: ${ASR_LICENSE_ID}
        ASR_LICENSE_CHANNELS: ${ASR_LICENSE_CHANNELS}
        TZ: ${TIMEZONE}
        CHECK_CONNECTION_WITH_SL: "true"
        LICENSE_HOST_PING: https://${LICENSE_HOST}/ping
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "5"
      volumes:
        - $TRD_LOG:/var/log/cpqd/
        - cache:/opt/cpqd/asr/license
  
  networks:
    default:
      driver: bridge
  
  volumes:
    cache:
  

Iniciando e parando os serviços

Para iniciar os serviços do Nó de Controle:

$ ./init_node_controller.sh

Para iniciar os serviços do Nó de Processamento:

$ ./init_node_processor.sh

Para parar os serviços do Nó de Controle:

$ docker-compose -f docker-compose_nd_controller.yml down

Para parar os serviços do Nó de Processamento:

$ docker-compose -f docker-compose_nd_processor.yml down

Visualizando os logs

Os logs são armazendos pelo docker, normalmente em: /var/lib/docker/containers/<container id>/<container id>-json.log

Para visualizar os logs dos containers Docker, utilize os comandos abaixo.

Na máquina do Nó de Controle:

$ docker-compose -f docker-compose_nd_controller.yml logs -f --tail 50

Na máquina do Nó de Processamento:

$ docker-compose -f docker-compose_nd_processor.yml logs -f --tail 50

Nota

Para o serviço de reconhecimento de fala, no nó de processamento, os logs são gravados na pasta /var/log/cpqd.