Instalação e Deploy do RUB

🛑Atenção

Governança e Stack de Infraestrutura: Os exemplos de instalação (Bare-Metal, Docker e Kubernetes) fornecidos neste guia sãoreferências técnicas. A stack tecnológica final, o uso de imagens base, o gerenciamento de segredos e a estratégia de deploy devem ser obrigatoriamente alinhados com a equipe de infraestrutura e seguir as diretrizes de governança de TI do cliente.

Este guia detalha os procedimentos para instalação do RUB em servidores Linux, cobrindo tanto a instalação direta ( Bare-Metal) quanto a utilização de containers Docker.

O RUB possui um serviço HTTP embutido, descartando a necessidade de servidores externos como Tomcat.

1. Instalação Bare-Metal (Serviço no Linux)

Esta seção descreve a instalação padrão diretamente no sistema operacional.

1.1 Estrutura de Diretórios

O RUB deve ser instalado preferencialmente no diretório /opt.

Estrutura da Aplicação (/opt/rub):

  • app/: Plugins e binários da aplicação.
  • clients/: Arquivos relacionados aos clientes.
  • configuration/: Arquivos de configuração (config.ini, connections.ini, etc).
  • framework/: Núcleo do sistema.
  • log/: Logs da aplicação (Referência: Logs).
  • services/: Binários de serviço.
  • etiqueta/: Modelos de etiquetas.
  • storage/: Dados persistentes.
  • biz/: Relatórios customizados.
  • pilulas/: Vídeos e metadados de treinamentos (Curtas).

Estrutura de Atualização (/opt/update):

  • versions/: Local para armazenar os arquivos ZIP enviados pela GIC.
  • release-update/: Local onde o ZIP é descompactado antes da sincronização.
  • backup/: Backups automáticos realizados antes de cada atualização.

1.2 Configuração Inicial

Arquivos em /opt/rub/configuration:

1.config.ini: Configurações gerais.

org.osgi.service.http.port=80
com.gicbrasil.rub.app=full
# Registro de Instância no Portal (Obrigatório em AD):
# O identificador deve ser obrigatoriamente um UUID único.
com.gicbrasil.rub.instance.identifier=550e8400-e29b-41d4-a716-446655440000
com.gicbrasil.rub.instance.description=Descrição da Instância
# com.gicbrasil.rub.instance.url=https://portal.gicbrasil.com/ (Não usar em RUB AD)
# Para Oracle:
# com.gicbrasil.rub.analytics.schemaRUB=usuario_rub
# Configuração de Loja (se não for multiloja):
# com.gicbrasil.rub.idEmpresa=17
# com.gicbrasil.rub.idLoja=170028

2.connections.ini: Conexões com banco de dados.

[rub]
url=jdbc:postgresql://localhost/rub
username=gic
password=rub#123

[analytics]
url=jdbc:postgresql://localhost/rub
username=analytics
password=rub#123

3.contexts.ini(Para ambientes multiloja):

[empresa]
com.gicbrasil.rub.idEmpresa=17
[loja05]
com.gicbrasil.rub.idEmpresa=17
com.gicbrasil.rub.idLoja=170005

1.3 Gestão de Licenças

As licenças devem ser colocadas em /opt/rub/configuration/licenca.dat. Em ambientes multiloja, use o padrão licenca.contexto.dat.

1.4 Mecanismo de Atualização (update.sh)

O script update.sh automatiza o processo de atualização, realizando backups e sincronizando os arquivos para o diretório de execução.

Script update.sh:

#!/bin/bash
# Script de Atualização e Instalação do RUB
# Uso: ./update.sh [-v]

VERSION_DIR="/opt/update/versions"
RELEASE_DIR="/opt/update/release-update"
BACKUP_BASE="/opt/update/backup"
RUB_DIR="/opt/rub"
DATE=$(date +%Y-%m-%d)

mkdir -p "$VERSION_DIR" "$RELEASE_DIR" "$BACKUP_BASE" "$RUB_DIR"

if [ "$1" == "-v" ]; then
    # Verifica se há um ZIP novo para processar
    LATEST_ZIP=$(ls -t $VERSION_DIR/*.zip 2>/dev/null | head -n 1)
    
    if [ -n "$LATEST_ZIP" ]; then
        echo "📦 Nova versão detectada: $(basename $LATEST_ZIP)"
        echo "📂 Extraindo para $RELEASE_DIR..."
        unzip -o "$LATEST_ZIP" -d "$RELEASE_DIR"
    fi

    echo "💾 Realizando backup da versão atual..."
    mkdir -p "$BACKUP_BASE/$DATE"
    for folder in app framework clients pilulas; do
        if [ -d "$RUB_DIR/$folder" ]; then
            cp -rf "$RUB_DIR/$folder" "$BACKUP_BASE/$DATE/"
        fi
    done

    echo "📄 Sincronizando arquivos para $RUB_DIR..."
    for folder in app framework clients services configuration pilulas; do
        if [ -d "$RELEASE_DIR/$folder" ]; then
            echo "✅ Atualizando: $folder"
            mkdir -p "$RUB_DIR/$folder"
            cp -rf "$RELEASE_DIR/$folder"/* "$RUB_DIR/$folder/"
        fi
    done

    echo "✨ Atualização concluída com sucesso!"
else
    echo "Uso: $0 -v (para processar a versão em $VERSION_DIR ou sincronizar $RELEASE_DIR)"
fi

Passos para atualização:

  1. Coloque o arquivo ZIP da versão em /opt/update/versions.
  2. Dê permissão de execução: chmod +x /opt/update/update.sh.
  3. Execute: /opt/update/update.sh -v.

Atualização de Plugin Único (Hotfix): Para atualizar apenas um plugin sem um ZIP completo:

  1. Coloque o arquivo .jar na pasta correta dentro de /opt/update/release-update/app ou /opt/update/release-update/framework.
  2. Execute o script: /opt/update/update.sh -v.

1.5 Configuração como Serviço (systemd)

Crie o link simbólico para o serviço:

ln -s /opt/rub/services/rub.service /etc/systemd/system/rub.service
systemctl daemon-reload
systemctl enable rub.service
systemctl start rub.service

2. Instalação via Docker (Alternativa)

A instalação via Docker utiliza os mesmos conceitos de diretórios e configurações, mas encapsula a aplicação em uma imagem auto-contida.

2.1 Dockerfile

O Dockerfile instala o RUB a partir do ZIP durante o build.

Script start.sh para Docker: Este script é utilizado como ENTRYPOINT no container, garantindo a sincronização de hotfixes e a correta inicialização da JVM.

#!/bin/sh
set -e

# --- CONFIGURAÇÃO DE AMBIENTE ---
FINAL_DATA_DIR="/opt/rub"
CONF_DIR="/mnt/conf"

finalize() {
  echo "🛑 Parando RUB e limpando processos..."
  killall java 2>/dev/null || true
  exit 0
}

trap 'finalize' SIGINT SIGTERM EXIT

# Aplica configurações customizadas montadas em /mnt/conf (Legado/Opcional)
if [ -d "$CONF_DIR" ] && [ "$(ls -A "$CONF_DIR" 2>/dev/null)" ]; then
    echo "⚙️  Aplicando arquivos de configuração customizados de $CONF_DIR..."
    cp -rf "$CONF_DIR"/* "$FINAL_DATA_DIR/"
fi

echo "🚀 Iniciando RUB em $FINAL_DATA_DIR..."
cd "$FINAL_DATA_DIR"

exec java ${JAVA_OPTS} -jar services/service.jar

Exemplo de Dockerfile:

FROM docker.io/eclipse-temurin:21-jre-alpine

RUN apk add --no-cache unzip

ARG RUB_SOURCE=deploy/rub-versao.zip
ARG JAVA_MEM="-Xmx1g"
ENV JAVA_OPTS="${JAVA_MEM}" RUB_HOME="/opt/rub"

RUN mkdir -p ${RUB_HOME}/log ${RUB_HOME}/etiqueta ${RUB_HOME}/configuration \
${RUB_HOME}/storage ${RUB_HOME}/biz ${RUB_HOME}/pilulas

WORKDIR ${RUB_HOME}

# Instalação no Build

COPY ${RUB_SOURCE} /tmp/rub.zip
RUN unzip -o /tmp/rub.zip -d ${RUB_HOME} && rm /tmp/rub.zip

COPY start.sh /usr/local/bin/start.sh
RUN chmod +x /usr/local/bin/start.sh

ENTRYPOINT ["/usr/local/bin/start.sh"]

2.2 Orquestração (Docker Compose)

services:
  rub-app:
    build:
      context: .
      args:
        - JAVA_MEM=-Xmx2g
    container_name: RUB
    volumes:
      - ./log:/opt/rub/log:rw,Z
      - ./configuration:/opt/rub/configuration:rw,Z
      - ./etiquetas:/opt/rub/etiqueta:rw,Z
      - ./storage:/opt/rub/storage:rw,Z
      - ./biz:/opt/rub/biz:rw,Z
      - ./pilulas:/opt/rub/pilulas:rw,Z
    environment:
      - JAVA_OPTS=-Dcom.gicbrasil.rub.instance.identifier=550e8400-e29b-41d4-a716-446655440001 -Dcom.gicbrasil.rub.instance.description="RUB Container 01" -Xmx2g
    ports:
      - "80:80"
    restart: always
💡Dica

Identificadores em AD: Para instâncias em cluster (Alta Disponibilidade), o identifier deve ser único para cada container. Se estiver utilizando múltiplos serviços no mesmo docker-compose.yml, certifique-se de alterar o valor para cada um (ex: NODE_01, NODE_02).

🛑Atenção

Build do Container: Como a instalação do RUB (extração do ZIP) ocorre durante a criação da imagem (comando RUN unzip no Dockerfile), * cada nova atualização de versão do RUB exige a execução obrigatória do build*: docker compose build --no-cache (seguido de docker compose up -d).

3. Orquestração em Kubernetes (K8s)

Para ambientes escaláveis, utilize o exemplo de Deployment abaixo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: rub-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: rub
  template:
    metadata:
      labels:
        app: rub
    spec:
      containers:
        - name: rub
          image: seu-registro/rub-image:latest
          ports:
            - containerPort: 80
          env:
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: JAVA_OPTS
              value: "-Dcom.gicbrasil.rub.instance.identifier=$(POD_NAME) -Dcom.gicbrasil.rub.instance.description='Pod $(POD_NAME)' -Xmx2g"
          volumeMounts:
            - name: rub-config
              mountPath: /opt/rub/configuration
            - name: rub-log
              mountPath: /opt/rub/log
            - name: rub-etiqueta
              mountPath: /opt/rub/etiqueta
            - name: rub-storage
              mountPath: /opt/rub/storage
            - name: rub-biz
              mountPath: /opt/rub/biz
            - name: rub-pilulas
              mountPath: /opt/rub/pilulas
      volumes:
        - name: rub-config
          persistentVolumeClaim:
            claimName: rub-config-pvc
        - name: rub-log
          persistentVolumeClaim:
            claimName: rub-log-pvc
        - name: rub-etiqueta
          persistentVolumeClaim:
            claimName: rub-etiqueta-pvc
        - name: rub-storage
          persistentVolumeClaim:
            claimName: rub-storage-pvc
        - name: rub-biz
          persistentVolumeClaim:
            claimName: rub-biz-pvc
        - name: rub-pilulas
          persistentVolumeClaim:
            claimName: rub-pilulas-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: rub-service
spec:
  selector:
    app: rub
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer
💡Dica

Persistência de Identidade no K8s: Ao utilizar o POD_NAME como identificador, cada réplica do Deployment terá um ID único. Para garantir que o identificador seja "persistente" (estável entre reinicializações de um nó lógico), recomenda-se o uso de** StatefulSets **, onde o nome do Pod (ex: rub-0, rub-1) é fixo.

4. Logs e Diagnóstico

Independentemente do método de instalação, os logs seguem o padrão RUB. Para detalhes sobre categorias e manutenção, consulte a Documentação de Logs.