Vai al contenuto principale
Questa sezione fornisce istruzioni per eseguire ABBYY FineReader Engine 12 all’interno di un container Docker. Questo scenario utilizza due container:
  1. un container con ABBYY FineReader Engine
  2. un container con il servizio di gestione delle licenze
L’implementazione di questo scenario aumenta la tolleranza agli errori e garantisce il funzionamento continuo di tutti i container. Se uno dei container si arresta, è possibile riavviarlo senza interrompere l’altro. Per questo scenario viene utilizzata una Online License, che si connette al server licenze *.abbyy.com.
ABBYY servizio di gestione delle licenze può funzionare solo con una Online License alla volta.
Sono necessari:
  • un file token di Online License
  • la password del file token di licenza
Per utilizzare una Online License ovunque sia installato ABBYY servizio di gestione delle licenze, è necessario soddisfare le seguenti condizioni:
  • Connessione Internet attiva
  • Connessioni consentite a *.abbyy.com sulla porta 443 (HTTPS)
  • GoDaddy Trusted Root Certification Authority inclusa nel pacchetto ca-certificates (per i dettagli, vedere il sito web di GoDaddy)
Per eseguire ABBYY FineReader Engine 12 in un container Docker:
  1. Scaricare e installare Docker e Docker Compose sul computer.
  2. Creare una directory vuota e inserirvi:
  • Dockerfile_ls — un Dockerfile per il container con il servizio di gestione delle licenze (vederne il contenuto di seguito)
Dockerfile_ls è destinato alla creazione di un container che funzionerà solo con un container creato da Dockerfile_worker . Non configurare più repliche del container con ABBYY FineReader Engine per lavorare con un unico servizio di gestione delle licenze.
Nota: questo container esegue il servizio di gestione delle licenze con la chiave /standalone. Con questa chiave, il servizio di gestione delle licenze viene eseguito come processo in primo piano, che è la procedura consigliata per l’uso nei container Docker.
  • Dockerfile_worker — un Dockerfile per il container con ABBYY FineReader Engine (vederne il contenuto di seguito)
  • wrapper.sh — uno script da riga di comando per eseguire l’esempio e visualizzarne i risultati nella console (vederne il contenuto di seguito)
  • docker-compose.yml — una configurazione di Docker Compose (vederne il contenuto di seguito)
Tenere presente che per il container con ABBYY FineReader Engine la dimensione di /dev/shm viene impostata manualmente in docker-compose.yml . Si consiglia di impostarla ad almeno 1 GB.
  • file distributivo di ABBYY FineReader Engine 12 (FREngine-Linux-%BUILD_ID%.sh)
  • file token di Online License
  1. Specificare i parametri della licenza nelle seguenti righe di docker-compose.yml:
args:
- license_token=SWRRXXXXXXXXXXXXXXXXXXXX.ABBYY.ActivationToken
- license_password=your_license_password
  1. Per creare ed eseguire i container, usa il seguente comando:
docker-compose up
I risultati dell’esempio verranno visualizzati nella console.
Puoi personalizzare gli argomenti predefiniti dell’esempio di codice CommandLineInterface (CLI) modificando la riga seguente nel file docker-compose.yml:
command: ["-if /app/Demo.tif -f TextUnicodeDefaults -of /app/Test.txt"]
Per i dettagli sugli argomenti della CLI, consulta la Libreria di esempi di codice.
Dockerfile_ls
# Fase 1.
# Da questa fase ricaviamo il servizio di gestione delle licenze
FROM ubuntu:bionic as builder
 
# Installa i pacchetti richiesti
RUN DEBIAN_FRONTEND=noninteractive \
    apt update \
    && apt install --no-install-recommends --yes \
    bash \
    gzip \
    tar \
    coreutils \
    gettext-base
COPY FRE*.sh /tmp/FRE12.sh
 
# Installa ABBYY FineReader Engine
RUN chmod +x /tmp/FRE12.sh && /tmp/FRE12.sh -- \
    --install-dir "/opt/ABBYY/FREngine12" \
    --skip-local-license-activation
 
# Fase 2. Usa un'immagine pulita
# Preparala per utilizzare il servizio di gestione delle licenze
FROM ubuntu:bionic
 
# Installa i pacchetti richiesti
RUN DEBIAN_FRONTEND=noninteractive \
    apt update \
    && apt install --no-install-recommends --yes \
    ca-certificates \
    bash \
    libc6 \
    libgcc-8-dev \
    libstdc++-8-dev
# Copia il servizio di gestione delle licenze dalla fase 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/
 
# Crea una cartella per il funzionamento del servizio di gestione delle licenze
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
# Fase 1. 
# Da qui prendiamo una directory con ABBYY FineReader Engine installato e l'esempio compilato
# Usa il container GCC ufficiale per ottenere tutti gli strumenti di sviluppo. 
# Usiamo GCC versione 8 solo come esempio, perché è la versione predefinita in ubuntu bionic
# puoi usare qualsiasi versione a partire dalla 4.8
FROM gcc:8 as builder
 
ARG license_token
ARG license_password
ARG service_address
# Copia il file del token di licenza e usalo per generare il file SamplesConfig.h corretto 
# durante il processo di installazione
COPY ${license_token} /tmp/${license_token}
 
COPY FRE*.sh /tmp/FRE12.sh
 
# Installa ABBYY FineReader Engine 12 e compila l'esempio
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
# Per copiare intere cartelle nella fase successiva, rimuovi tutti i file non necessari dal
# pacchetto di distribuzione di ABBYY FineReader Engine installato
RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so
 
# Fase 2. Usa un'immagine pulita 
# Preparala per l'uso di ABBYY FineReader Engine
# In questa fase usiamo un'immagine ubuntu minimale senza strumenti di sviluppo
FROM ubuntu:bionic
 
# Installa i pacchetti necessari 
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
# Copia ABBYY FineReader Engine dalla fase 1
COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data
# Crea una cartella per il funzionamento del Licensing Service e l'archiviazione della cache
# Copia il file del token di licenza in questa cartella
COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.ActivationToken /var/lib/ABBYY/SDK/12/Licenses/
# Copia l'esempio compilato e l'immagine dimostrativa
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 per avviare l'esempio e visualizzare il risultato nella console
COPY ./wrapper.sh /wrapper.sh
RUN chmod +x /wrapper.sh
ENTRYPOINT ["/wrapper.sh"]

#!/bin/bash
 
# Avvia l'esempio
/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

​
Vedi anche

Installazione del servizio di gestione delle licenze su Linux Gestione delle licenze Attivazione