Passer au contenu principal
Cette section explique comment exécuter ABBYY FineReader Engine 12 dans un conteneur Docker. Ce scénario utilise deux conteneurs :
  1. un conteneur avec ABBYY FineReader Engine
  2. un conteneur avec le service de licence
La mise en œuvre de ce scénario améliore la tolérance aux pannes et garantit le fonctionnement continu de tous les conteneurs. Si l’un des conteneurs tombe en panne, vous pouvez le redémarrer sans interrompre l’autre. Une licence en ligne, qui se connecte au serveur de licences *.abbyy.com, est utilisée dans ce scénario.
ABBYY Licensing Service ne peut fonctionner qu’avec une seule licence en ligne à la fois.
Vous avez besoin de :
  • un fichier de jeton de licence en ligne
  • le mot de passe du fichier de jeton de licence
Pour utiliser une licence en ligne partout où ABBYY Licensing Service est installé, les conditions suivantes doivent être remplies :
  • Connexion Internet active
  • Connexions autorisées à *.abbyy.com sur le port 443 (HTTPS)
  • Autorité de certification racine de confiance GoDaddy incluse dans le package ca-certificates (voir les détails sur le site web de GoDaddy)
Pour exécuter ABBYY FineReader Engine 12 dans un conteneur Docker :
  1. Téléchargez et installez Docker et Docker Compose sur votre machine.
  2. Créez un répertoire vide et placez-y :
  • Dockerfile_ls — un Dockerfile pour le conteneur du service de licence (voir son contenu ci-dessous)
Dockerfile_ls est conçu pour créer un conteneur qui fonctionnera avec un seul conteneur créé à partir de Dockerfile_worker . Ne configurez pas plusieurs réplicas du conteneur avec ABBYY FineReader Engine pour qu’ils fonctionnent avec un seul service de licence.
Remarque : ce conteneur exécute le service de licence avec la clé /standalone. Avec cette clé, le service de licence s’exécute au premier plan, ce qui constitue la bonne pratique pour une utilisation dans des conteneurs Docker.
  • Dockerfile_worker — un Dockerfile pour le conteneur avec ABBYY FineReader Engine (voir son contenu ci-dessous)
  • wrapper.sh — un script en ligne de commande permettant d’exécuter l’exemple et d’afficher ses résultats dans la console (voir son contenu ci-dessous)
  • docker-compose.yml — un fichier de configuration Docker Compose (voir son contenu ci-dessous)
Notez que, pour le conteneur avec ABBYY FineReader Engine, nous définissons manuellement la taille de /dev/shm dans docker-compose.yml . Nous vous recommandons de la définir sur au moins 1 GB.
  • fichier de distribution ABBYY FineReader Engine 12 (FREngine-Linux-%BUILD_ID%.sh)
  • fichier de jeton de licence en ligne
  1. Spécifiez les paramètres de votre licence dans les lignes suivantes de docker-compose.yml :
args:
- license_token=SWRRXXXXXXXXXXXXXXXXXXXX.ABBYY.ActivationToken
- license_password=your_license_password
  1. Pour créer et exécuter les conteneurs, utilisez la commande suivante :
docker-compose up
Les résultats de l’exemple seront affichés dans la console.
Vous pouvez personnaliser les arguments par défaut de l’exemple de code CommandLineInterface (CLI) en modifiant la ligne suivante dans docker-compose.yml :
command: ["-if /app/Demo.tif -f TextUnicodeDefaults -of /app/Test.txt"]
Consultez le détail des arguments de la CLI dans la bibliothèque d’exemples de code.
Dockerfile_ls
# Étape 1.
# À partir de cette étape, nous récupérons le service de licence
FROM ubuntu:bionic as builder
 
# Installer les paquets requis
RUN DEBIAN_FRONTEND=noninteractive \
    apt update \
    && apt install --no-install-recommends --yes \
    bash \
    gzip \
    tar \
    coreutils \
    gettext-base
COPY FRE*.sh /tmp/FRE12.sh
 
# Installer ABBYY FineReader Engine
RUN chmod +x /tmp/FRE12.sh && /tmp/FRE12.sh -- \
    --install-dir "/opt/ABBYY/FREngine12" \
    --skip-local-license-activation
 
# Étape 2. Prendre une image propre
# La préparer à utiliser le service de licence
FROM ubuntu:bionic
 
# Installer les paquets requis
RUN DEBIAN_FRONTEND=noninteractive \
    apt update \
    && apt install --no-install-recommends --yes \
    ca-certificates \
    bash \
    libc6 \
    libgcc-8-dev \
    libstdc++-8-dev
# Copier le service de licence depuis l'étape 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/
 
# Créer un dossier pour le fonctionnement du service de licence
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
# Étape 1. 
# À partir de cette étape, nous récupérons un répertoire dans lequel ABBYY FineReader Engine est installé, ainsi que l’exemple compilé
# Utilisez le conteneur GCC officiel pour disposer de tous les outils de développement. 
# Nous utilisons la version 8 de GCC uniquement à titre d’exemple, car il s’agit de la version par défaut dans Ubuntu Bionic
# vous pouvez utiliser n’importe quelle version à partir de la 4.8
FROM gcc:8 as builder
 
ARG license_token
ARG license_password
ARG service_address
# Copiez le fichier de jeton de licence et utilisez-le pour générer le fichier SamplesConfig.h approprié 
# pendant le processus d’installation
COPY ${license_token} /tmp/${license_token}
 
COPY FRE*.sh /tmp/FRE12.sh
 
# Installez ABBYY FineReader Engine 12 et compilez l’exemple
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
# Pour copier des dossiers entiers à l’étape suivante, supprimez tous les fichiers inutiles du
# kit de distribution de ABBYY FineReader Engine installé
RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so
 
# Étape 2. Utiliser une image propre 
# La préparer pour utiliser ABBYY FineReader Engine
# À cette étape, nous utilisons une image Ubuntu minimaliste sans outils de développement
FROM ubuntu:bionic
 
# Installer les paquets requis 
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
# Copier ABBYY FineReader Engine depuis l’étape 1
COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data
# Créer un dossier pour le fonctionnement du service de licence et le stockage du cache
# Copier le fichier de jeton de licence dans ce dossier
COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.ActivationToken /var/lib/ABBYY/SDK/12/Licenses/
# Copier l’exemple compilé et l’image de démonstration
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 permettant de lancer l’exemple et d’afficher le résultat dans la console
COPY ./wrapper.sh /wrapper.sh
RUN chmod +x /wrapper.sh
ENTRYPOINT ["/wrapper.sh"]

#!/bin/bash
 
# Lancer l’exemple
/app/CommandLineInterface $1
status=$?
if [ $status -ne 0 ]; then
  echo "Échec du lancement de l’application : $status"
  exit $status
fi
cat ${1##*-of}
echo "Terminé"

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

​
Voir aussi

Installation du service de licence sous Linux Licence Activation