Pular para o conteúdo principal
Esta seção fornece instruções para executar o ABBYY FineReader Engine 12 em um contêiner Docker. Este cenário usa dois contêineres:
  1. um contêiner com o ABBYY FineReader Engine
  2. um contêiner com o Serviço de Licenciamento
A implementação deste cenário aumenta a tolerância a falhas e garante a operação contínua de todos os contêineres. Se um dos contêineres falhar, você poderá reiniciá-lo sem interromper o outro. Uma Online License, que se conecta ao servidor de licenças *.abbyy.com, é usada neste cenário.
O ABBYY Serviço de Licenciamento pode funcionar com apenas uma Online License por vez.
Você precisa de:
  • um arquivo de token da Online License
  • a senha do arquivo de token da licença
Para usar uma Online License em qualquer local em que o ABBYY Serviço de Licenciamento esteja instalado, é preciso atender às seguintes condições:
  • Conexão ativa com a Internet
  • Conexões permitidas para *.abbyy.com na porta 443 (HTTPS)
  • GoDaddy Trusted Root Certification Authority incluída no pacote ca-certificates (veja os detalhes no site da GoDaddy)
Para executar o ABBYY FineReader Engine 12 em um contêiner Docker:
  1. Baixe e instale o Docker e o Docker Compose na sua máquina.
  2. Crie um diretório vazio e coloque nele:
  • Dockerfile_ls — um Dockerfile para o contêiner com o Serviço de Licenciamento (veja sua listagem abaixo)
O Dockerfile_ls foi projetado para criar um contêiner que funcionará com apenas um contêiner criado a partir do Dockerfile_worker . Não configure várias réplicas do contêiner com o ABBYY FineReader Engine para funcionar com um único Serviço de Licenciamento.
Observação: este contêiner executa o Serviço de Licenciamento com a chave /standalone. Com essa chave, o Serviço de Licenciamento funciona como um processo em primeiro plano, o que é a prática recomendada para trabalhar com contêineres Docker.
  • Dockerfile_worker — um Dockerfile para o contêiner com o ABBYY FineReader Engine (veja sua listagem abaixo)
  • wrapper.sh — um script de linha de comando para executar o exemplo e exibir os resultados no console (veja sua listagem abaixo)
  • docker-compose.yml — uma configuração do Docker Compose (veja sua listagem abaixo)
Observe que, para o contêiner com o ABBYY FineReader Engine, definimos manualmente o tamanho de /dev/shm em docker-compose.yml . Recomendamos defini-lo com pelo menos 1 GB.
  • arquivo distributivo do ABBYY FineReader Engine 12 (FREngine-Linux-%BUILD_ID%.sh)
  • arquivo de token da Online License
  1. Especifique os parâmetros da sua licença nas seguintes linhas do docker-compose.yml:
args:
- license_token=SWRRXXXXXXXXXXXXXXXXXXXX.ABBYY.ActivationToken
- license_password=your_license_password
  1. Para criar e executar os contêineres, use o seguinte comando:
docker-compose up
Os resultados do exemplo serão exibidos no console.
Você pode personalizar os argumentos padrão do exemplo de código CommandLineInterface (CLI) editando a linha a seguir no docker-compose.yml:
command: ["-if /app/Demo.tif -f TextUnicodeDefaults -of /app/Test.txt"]
Consulte os detalhes dos argumentos da CLI na Biblioteca de Exemplos de Código.
Dockerfile_ls
# Estágio 1.
# Desta parte, usamos o Licensing Service
FROM ubuntu:bionic as builder
 
# Instale os pacotes necessários
RUN DEBIAN_FRONTEND=noninteractive \
    apt update \
    && apt install --no-install-recommends --yes \
    bash \
    gzip \
    tar \
    coreutils \
    gettext-base
COPY FRE*.sh /tmp/FRE12.sh
 
# Instale o ABBYY FineReader Engine
RUN chmod +x /tmp/FRE12.sh && /tmp/FRE12.sh -- \
    --install-dir "/opt/ABBYY/FREngine12" \
    --skip-local-license-activation
 
# Estágio 2. Use uma imagem limpa
# Prepare-a para usar o Licensing Service
FROM ubuntu:bionic
 
# Instale os pacotes necessários
RUN DEBIAN_FRONTEND=noninteractive \
    apt update \
    && apt install --no-install-recommends --yes \
    ca-certificates \
    bash \
    libc6 \
    libgcc-8-dev \
    libstdc++-8-dev
# Copie o Licensing Service do estágio 1
COPY --from=builder /usr/local/bin/ABBYY/SDK/12/Licensing /usr/local/bin/ABBYY/SDK/12/Licensing/
COPY --from=builder /usr/local/lib/ABBYY/SDK/12/Licensing /usr/local/lib/ABBYY/SDK/12/Licensing/
 
# Crie uma pasta para o funcionamento do Licensing Service
RUN mkdir /var/lib/ABBYY/SDK/12/Licenses -p && chmod 755 /var/lib/ABBYY/SDK/12/Licenses
 
ENV LD_LIBRARY_PATH=/usr/local/lib/ABBYY/SDK/12/Licensing
 
EXPOSE 3023
 
ENTRYPOINT ["/usr/local/bin/ABBYY/SDK/12/Licensing/LicensingService", "/standalone"]
Dockerfile_worker
# Etapa 1. 
# Desta etapa, aproveitamos o diretório com o ABBYY FineReader Engine instalado e o exemplo compilado
# Use a imagem oficial do GCC para obter todas as ferramentas de desenvolvimento. 
# Usamos a versão 8 do GCC apenas como exemplo, porque ela é a versão padrão no ubuntu bionic
# você pode usar qualquer versão a partir da 4.8
FROM gcc:8 as builder
 
ARG license_token
ARG license_password
ARG service_address
# Copie o arquivo do token de licença e use-o para gerar o SamplesConfig.h correto 
# durante o processo de instalação
COPY ${license_token} /tmp/${license_token}
 
COPY FRE*.sh /tmp/FRE12.sh
 
# Instale o ABBYY FineReader Engine 12 e compile o exemplo
RUN chmod +x /tmp/FRE12.sh && /tmp/FRE12.sh -- \
    --install-dir "/opt/ABBYY/FREngine12" \
    --license-path "/tmp/${license_token}" \
    --license-password "${license_password}" \
    --service-address "${service_address}" \
    --developer-install
WORKDIR /opt/ABBYY/FREngine12/Samples/CommandLineInterface
RUN make
# Para copiar pastas inteiras na próxima etapa, remova todos os arquivos desnecessários do
# kit de distribuição do ABBYY FineReader Engine instalado
RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so
 
# Etapa 2. Use uma imagem limpa 
# Prepare-a para usar o ABBYY FineReader Engine
# Nesta etapa, usamos uma imagem mínima do ubuntu sem ferramentas de desenvolvimento
FROM ubuntu:bionic
 
# Instale os pacotes necessários 
RUN DEBIAN_FRONTEND=noninteractive \
    apt update \
    && apt install --no-install-recommends --yes \
    ca-certificates \
    bash \
    libc6 \
    libglib2.0-0 \
    libgcc-8-dev \
    libstdc++-8-dev \
    zlib1g \
    libx11-6 \
    libfreetype6 \
    libxext-dev \
    libice-dev \
    libsm-dev \
    locales \
    && locale-gen en_US.UTF-8
# Copie o ABBYY FineReader Engine da etapa 1
COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data
# Crie uma pasta para o funcionamento do serviço de licenciamento e o armazenamento em cache
# Copie o arquivo do token de licença para essa pasta
COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.ActivationToken /var/lib/ABBYY/SDK/12/Licenses/
# Copie o exemplo compilado e a imagem de demonstração
COPY --from=builder /opt/ABBYY/FREngine12/Samples/CommandLineInterface/CommandLineInterface /app/
COPY --from=builder /opt/ABBYY/FREngine12/Samples/SampleImages/Demo.tif /app/
ENV LD_LIBRARY_PATH=/opt/ABBYY/FREngine12/Bin
# wrapper.sh - script para iniciar o exemplo e exibir o resultado no console
COPY ./wrapper.sh /wrapper.sh
RUN chmod +x /wrapper.sh
ENTRYPOINT ["/wrapper.sh"]

#!/bin/bash
 
# Inicia o exemplo
/app/CommandLineInterface $1
status=$?
if [ $status -ne 0 ]; then
  echo "Failed to launch app: $status"
  exit $status
fi
cat ${1##*-of}
echo "Done"

version: '3'
services:
  worker:
    build:
      context: .
      dockerfile: Dockerfile_worker
      args:
        - license_token=SWRRXXXXXXXXXXXXXXXXXXXX.ABBYY.ActivationToken
        - license_password=your_license_password
        - service_address=ls
    depends_on:
      - ls
    shm_size: 1g
    command: ["-if /app/Demo.tif -f TextUnicodeDefaults -of /app/Test.txt"]
    restart: on-failure
  ls:
    build:
      context: .
      dockerfile: Dockerfile_ls
    restart: on-failure

​
Veja também

Instalando o Serviço de Licenciamento no Linux Licenciamento Ativação