Zum Hauptinhalt springen

Documentation Index

Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt

Use this file to discover all available pages before exploring further.

Dieses Thema beschreibt, wie Sie ABBYY FineReader Engine 12 in Docker-Containern unter Linux ausführen. In diesem Thema werden zwei Einrichtungsoptionen behandelt:
OptionBeschreibung
Einzelner ContainerLicensing Service und FRE-Worker zusammen in einem Container gebündelt.

Einfacher; gut für Tests, Demos und einmalige OCR-Jobs.
Zwei ContainerLicensing Service und FRE-Worker in separaten Containern.

Bessere Fehlertoleranz; wenn einer abstürzt, kann er neu gestartet werden, ohne den anderen zu beeinträchtigen. Mehrere Worker können sich einen Licensing Service teilen.
Beide Einrichtungsoptionen unterstützen Online-Lizenzen und lokale Lizenzen, und beide basieren auf ubuntu:noble (24.04 LTS).

​
Lizenztypen

FRE 12 unterstützt zwei Lizenztypen: Online und lokal. Beide Typen funktionieren sowohl in Einzel-Container- als auch in Zwei-Container-Setups, stellen jedoch unterschiedliche Anforderungen an die Aktivierung und die Runtime.

​
Online-Lizenz

  • Dateinamenmuster: XXXXXXXXXXXXXXXXXXXX.ABBYY.ActivationToken
  • Wird zur Laufzeit über *.abbyy.com überprüft — für jeden Container-Start ist ein Internetzugang erforderlich.
  • Voraussetzungen überall, wo der Licensing Service installiert ist:
    • Aktive Internetverbindung
    • Ausgehende HTTPS-Verbindungen (Port 443) zu *.abbyy.com müssen erlaubt sein
    • GoDaddy Trusted Root CA im Systempaket ca-certificates (bereits in ubuntu:noble enthalten)
  • Eine einzelne Licensing Service-Instanz kann jeweils nur mit einer Online-Lizenz gleichzeitig arbeiten.

​
Lokale Lizenz

  • Dateinamenmuster: XXXX-XXXX-XXXX-XXXX-XXXX-XXXX.ABBYY.LocalLicense
  • Wird während des Builds bei der FRE-Installation aktiviert und anschließend ins Image integriert.
  • Keine Internetverbindung zur Laufzeit erforderlich — ideal für Air-Gap-Umgebungen.

​
Erste Schritte

Um eine der beiden Einrichtungsoptionen in diesem Leitfaden nutzen zu können, benötigen Sie:
  • Docker und Docker Compose (docker compose-Syntax v2) müssen installiert sein
  • das Linux-Installationsprogramm für ABBYY FineReader Engine 12: FRE*.sh
  • eine Lizenzdatei (.ABBYY.ActivationToken oder .ABBYY.LocalLicense) und das Kennwort

​
Einrichtungsoption 1 — Einzelner Container

Diese Option führt den Licensing Service und den FRE-Worker in einem Container aus. Der Einstiegspunkt startet den Licensing Service im Hintergrund, wartet kurz, bis dieser bereit ist, führt das CLI-Sample aus, gibt die Ausgabe aus und beendet beim Beenden alle Prozesse ordnungsgemäß.Empfohlen für lokale Tests, Demos und CI-Jobs, bei denen ein einziger Befehl zum Starten und Stoppen genügt.

​
Dateien

Erstellen Sie ein leeres Verzeichnis und fügen Sie die folgenden Dateien hinzu:
  • Dockerfile — erstellt das kombinierte Docker-Image (siehe unten)
  • entrypoint.sh — startet den LS, führt das CLI-Beispiel aus und gibt das Ergebnis aus (unten aufgeführt)
  • docker-compose.yml — baut und startet den Container (unten aufgeführt)
  • .env — enthält den Namen Ihrer Lizenzdatei und Ihr Kennwort (unten aufgeführt)

​
Erstellen und ausführen

  1. Kopieren Sie Ihr FRE*.sh-Installationsprogramm und Ihre Lizenzdatei in das Verzeichnis, das Sie oben angelegt haben.
  2. Erstellen Sie eine .env-Datei mit den Werten Ihrer Lizenz (siehe unten).
  3. Führen Sie in diesem Verzeichnis den folgenden Befehl aus, um das Image zu erstellen und den Container zu starten: 
    docker compose up
Das CLI-Beispiel verarbeitet die mitgelieferte Demo.tif mithilfe von Optical Character Recognition (OCR) und gibt den erkannten Text auf der Konsole aus.

​
.env

# Für eine lokale Lizenz:
LICENSE_FILE=XXXX-XXXX-XXXX-XXXX-XXXX-XXXX.ABBYY.LocalLicense
# Für eine Online-Lizenz:
# LICENSE_FILE=XXXXXXXXXXXXXXXXXXXX.ABBYY.ActivationToken
LICENSE_PASSWORD=your_password_here

​
docker-compose.yml

services:
  fre:
    build:
      context: .
      args:
        - license_file=${LICENSE_FILE}
        - license_password=${LICENSE_PASSWORD}
    shm_size: 1g
    command: ["-if /app/Demo.tif -f TextUnicodeDefaults -of /app/Test.txt"]
shm_size: 1g ist erforderlich. FRE verwendet gemeinsamen POSIX-Speicher, und die standardmäßigen 64 MB /dev/shm sind nicht ausreichend. Entfernen oder ändern Sie diese Einstellung nicht.

​
Dockerfile

Dies ist ein zweistufiger Build:
  • In Stufe 1 wird gcc:8 verwendet, um FRE zu installieren und das CLI-Beispiel zu kompilieren.
  • Stufe 2 erstellt ein minimales ubuntu:noble-Runtime-Image und kopiert die Binärdateien des Licensing Service, die FRE-Runtime, das kompilierte Beispiel und die Lizenzdatei hinein.
# Stufe 1: FRE installieren und das CLI-Beispiel kompilieren
FROM gcc:8 AS builder

ARG license_file
ARG license_password

COPY ${license_file} /tmp/${license_file}
COPY FRE*.sh /tmp/FRE12.sh

RUN chmod +x /tmp/FRE12.sh && /tmp/FRE12.sh -- \
    --install-dir "/opt/ABBYY/FREngine12" \
    --license-path "/tmp/${license_file}" \
    --license-password "${license_password}" \
    --developer-install

WORKDIR /opt/ABBYY/FREngine12/Samples/CommandLineInterface
RUN make

# Nur für Entwickler vorgesehene Bibliothek entfernen (zur Laufzeit nicht benötigt)
RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so

# Stufe 2: Minimales Laufzeit-Image mit Licensing Service und FRE
FROM ubuntu:noble

RUN DEBIAN_FRONTEND=noninteractive apt-get update && \
    apt-get install --no-install-recommends -y \
    ca-certificates bash libc6 libglib2.0-0 libgcc-s1 libstdc++6 \
    zlib1g libx11-6 libfreetype6 libxext-dev libice-dev libsm-dev \
    locales && \
    locale-gen en_US.UTF-8 && \
    rm -rf /var/lib/apt/lists/*

# Licensing Service kopieren
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/

# FRE-Laufzeit-Binärdateien und Daten kopieren
COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data

# Lizenzdatei kopieren (funktioniert sowohl für .ActivationToken als auch für .LocalLicense)
COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.* /var/lib/ABBYY/SDK/12/Licenses/

# Kompiliertes CLI-Beispiel und Demo-Image kopieren
COPY --from=builder /opt/ABBYY/FREngine12/Samples/CommandLineInterface/CommandLineInterface /app/
COPY --from=builder /opt/ABBYY/FREngine12/Samples/SampleImages/Demo.tif /app/

# Arbeitsverzeichnis für Lizenzen erstellen
RUN mkdir -p /var/lib/ABBYY/SDK/12/Licenses && chmod 755 /var/lib/ABBYY/SDK/12/Licenses

ENV LD_LIBRARY_PATH=/opt/ABBYY/FREngine12/Bin:/usr/local/lib/ABBYY/SDK/12/Licensing
ENV LANG=en_US.UTF-8
ENV LC_ALL=en_US.UTF-8

COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

ENTRYPOINT ["/entrypoint.sh"]

​
entrypoint.sh

#!/bin/bash

# Licensing Service im Hintergrund starten
/usr/local/bin/ABBYY/SDK/12/Licensing/LicensingService /standalone &
LS_PID=$!

# Warten, bis der Licensing Service bereit ist
sleep 2

# CLI-Beispiel ausführen
/app/CommandLineInterface $1

status=$?
if [ $status -ne 0 ]; then
  echo "Failed to launch app: $status"
  kill $LS_PID 2>/dev/null
  exit $status
fi

# Inhalt der Ausgabedatei anzeigen
cat ${1##*-of}
echo "Done"

# Aufräumen
kill $LS_PID 2>/dev/null

​
Einrichtungsoption 2 — Zwei Container

Bei dieser Option werden der Licensing Service und der FRE-Worker in separaten Containern in einem gemeinsamen Docker Compose-Netzwerk ausgeführt. Der Worker kommuniziert mit dem Licensing Service über TCP unter ls:3023.Empfohlen für Produktivumgebungen. Wenn die Dienste in separaten Containern ausgeführt werden, kann Docker jeden von beiden unabhängig neu starten, falls er abstürzt. Außerdem können so mehrere Worker eine Verbindung zum selben Licensing Service herstellen.
Betreiben Sie nicht mehrere Worker-Replikate gegen einen einzelnen Licensing Service, sofern Ihre Lizenz dies nicht gestattet. Eine einzelne Licensing Service-Instanz unterstützt jeweils nur eine Online-Lizenz.

​
Dateien

Erstellen Sie ein leeres Verzeichnis und fügen Sie die folgenden Dateien hinzu:
  • Dockerfile_ls — erstellt den Container für den Licensing Service (unten aufgeführt)
  • Dockerfile_worker — erstellt den FRE-Worker-Container (siehe unten)
  • entrypoint.sh — führt das CLI-Beispiel im Worker aus (wie unten aufgeführt)
  • docker-compose.yml — verknüpft die beiden Container miteinander (wie unten aufgeführt)
  • .env — enthält den Dateinamen Ihrer Lizenz und Ihr Kennwort (gleiches Format wie bei Setup 1)

​
Erstellen und ausführen

  1. Kopieren Sie Ihr FRE*.sh-Installationsprogramm und die Lizenzdatei in das Verzeichnis.
  2. Erstellen Sie eine .env-Datei mit den Werten Ihrer Lizenz.
  3. Führen Sie in diesem Verzeichnis Folgendes aus: 
    docker compose up
Beide Container werden erstellt und gestartet. Der Licensing Service startet zuerst, gefolgt vom Worker, der das CLI-Beispiel mit der mitgelieferten Demo.tif ausführt und das Ergebnis ausgibt.

​
docker-compose.yml

services:
  ls:
    build:
      context: .
      dockerfile: Dockerfile_ls
    restart: on-failure

  worker:
    build:
      context: .
      dockerfile: Dockerfile_worker
      args:
        - license_file=${LICENSE_FILE}
        - license_password=${LICENSE_PASSWORD}
        - service_address=ls:3023
    depends_on:
      - ls
    shm_size: 1g
    command: ["-if /app/Demo.tif -f TextUnicodeDefaults -of /app/Test.txt"]
    restart: on-failure
Einige wichtige Hinweise:
  • Der Worker verwendet depends_on: [ls], damit der Licensing Service-Container zuerst startet.
  • Beide Dienste verwenden restart: on-failure, sodass sie unabhängig voneinander wieder starten können.
  • Das service_address-Build-Argument des Workers ist ls:3023 — das integrierte DNS von Docker Compose löst ls zum Licensing Service-Container auf.
  • shm_size: 1g wird für den Worker und nicht für den Licensing Service konfiguriert, da FRE Shared Memory benötigt.

​
Dockerfile_ls

Dies ist ein zweistufiger Build:
  • Stufe 1 führt das FRE-Installationsprogramm mit --skip-local-license-activation aus, um die Binärdateien des Licensing Service zu entpacken.
  • Stufe 2 erstellt ein minimales ubuntu:noble-Runtime-Image, gibt Port 3023 frei und führt LicensingService /standalone als PID 1 aus. Das Flag /standalone hält den Licensing Service im Vordergrund, was in Docker der richtige Ansatz ist (ein Vordergrundprozess schreibt Protokolle in die Standardausgabe und wird sauber beendet, wenn der Container gestoppt wird).
# Stufe 1: Licensing Service aus dem FRE-Installationsprogramm extrahieren
FROM ubuntu:noble AS builder

RUN DEBIAN_FRONTEND=noninteractive apt-get update && \
    apt-get install --no-install-recommends -y \
    bash gzip tar coreutils gettext-base && \
    rm -rf /var/lib/apt/lists/*

COPY FRE*.sh /tmp/FRE12.sh

RUN chmod +x /tmp/FRE12.sh && /tmp/FRE12.sh -- \
    --install-dir "/opt/ABBYY/FREngine12" \
    --skip-local-license-activation

# Stufe 2: Minimale Laufzeitumgebung für den Licensing Service
FROM ubuntu:noble

RUN DEBIAN_FRONTEND=noninteractive apt-get update && \
    apt-get install --no-install-recommends -y \
    ca-certificates bash libc6 libgcc-s1 libstdc++6 && \
    rm -rf /var/lib/apt/lists/*

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/

RUN mkdir -p /var/lib/ABBYY/SDK/12/Licenses && 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

Dies ist ein zweistufiger Build:
  • Stufe 1 installiert FRE mit --developer-install, wobei --service-address auf den Licensing Service-Container verweist, und kompiliert dann das CLI-Beispiel.
  • Stufe 2 erstellt ein minimales ubuntu:noble-Runtime-Image, das nur die FRE-Binärdateien, das kompilierte Beispiel und das Demo-Image enthält. Da der Worker über das Netzwerk mit dem ls-Container kommuniziert, sind keine Binärdateien des Licensing Service enthalten.
# Stufe 1: FRE installieren und das CLI-Beispiel kompilieren
FROM gcc:8 AS builder

ARG license_file
ARG license_password
ARG service_address

COPY ${license_file} /tmp/${license_file}
COPY FRE*.sh /tmp/FRE12.sh

RUN chmod +x /tmp/FRE12.sh && /tmp/FRE12.sh -- \
    --install-dir "/opt/ABBYY/FREngine12" \
    --license-path "/tmp/${license_file}" \
    --license-password "${license_password}" \
    --service-address "${service_address}" \
    --developer-install

WORKDIR /opt/ABBYY/FREngine12/Samples/CommandLineInterface
RUN make

# Nur für Entwickler vorgesehene Bibliothek entfernen (zur Laufzeit nicht benötigt)
RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so

# Stufe 2: Minimales Laufzeit-Image
FROM ubuntu:noble

RUN DEBIAN_FRONTEND=noninteractive apt-get update && \
    apt-get install --no-install-recommends -y \
    ca-certificates bash libc6 libglib2.0-0 libgcc-s1 libstdc++6 \
    zlib1g libx11-6 libfreetype6 libxext-dev libice-dev libsm-dev \
    locales && \
    locale-gen en_US.UTF-8 && \
    rm -rf /var/lib/apt/lists/*

# FRE-Laufzeit-Binärdateien und Daten kopieren
COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data

# Lizenzdatei kopieren (funktioniert sowohl für .ActivationToken als auch für .LocalLicense)
COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.* /var/lib/ABBYY/SDK/12/Licenses/

# Kompiliertes CLI-Beispiel und Demo-Image kopieren
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
ENV LANG=en_US.UTF-8
ENV LC_ALL=en_US.UTF-8

COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

ENTRYPOINT ["/entrypoint.sh"]

​
entrypoint.sh

Der Einstiegspunkt des Workers ist einfacher als bei der Single-Container-Version, da er den Licensing Service nicht verwaltet. Der Worker führt lediglich das Sample aus und gibt die Ausgabe aus.
#!/bin/bash

# CLI-Beispiel mit den angegebenen Argumenten ausführen
/app/CommandLineInterface $1

status=$?
if [ $status -ne 0 ]; then
  echo "Failed to launch app: $status"
  exit $status
fi

# Inhalt der Ausgabedatei anzeigen
cat ${1##*-of}
echo "Done"

​
Anpassen des CLI-Beispiels

Beide Einrichtungsoptionen führen denselben Standardbefehl in docker-compose.yml aus: 
command: ["-if /app/Demo.tif -f TextUnicodeDefaults -of /app/Test.txt"]
  • -if — Eingabedatei
  • -f — Ausgabeformatprofil
  • -of — Ausgabedatei
Passen Sie diese Zeile an, sodass sie auf eine andere Eingabe-, Ausgabe- oder Formatprofildatei verweist. Siehe die Dokumentation der FRE Code Samples Library für die vollständige Liste der CLI-Argumente.
Um OCR auf Ihren eigenen Dateien auszuführen, binden Sie ein Host-Verzeichnis per Bind-Mount in /app ein und verweisen Sie -if/-of auf Dateien darin.

​
Häufige Probleme

Im Folgenden sind bekannte Probleme aufgeführt, die für beide Einrichtungsoptionen gelten:
  • shm_size: 1g ist zwingend erforderlich. FRE ist auf POSIX Shared Memory angewiesen, und die standardmäßige Zuweisung von 64 MB für /dev/shm reicht nicht aus. Die obigen Compose-Dateien setzen dies beim Worker-Service bereits.
  • Das Installationsprogramm und die Lizenzdatei müssen im Build-Kontext vorhanden sein. Beide Dockerfiles COPYen FRE*.sh und die Lizenzdatei — befinden sie sich nicht in dem Verzeichnis, aus dem Sie den Build starten, schlägt der Build sofort fehl. Binden Sie die Lizenz nicht zur Laufzeit ein. Sie wird während des Builds aktiviert.
  • Online-Lizenzen benötigen ausgehenden Netzwerkzugriff sowohl vom Builder als auch von der Laufzeitumgebung. Der Builder benötigt ihn für die Aktivierung; der Licensing Service der Runtime benötigt ihn, um die Lizenz fortlaufend zu validieren.
  • Committen Sie keine Lizenzdateien oder Installationsprogramme. Fügen Sie in der Quellcodeverwaltung .env, *.ABBYY.* und FRE*.sh zu Ihrer Ignore-Liste hinzu, und nehmen Sie sie nicht in veröffentlichte Images auf, wenn Sie die Folgen und Risiken nicht genau kennen.
  • Diese Beispiele verwenden ubuntu:noble (24.04 LTS). In früheren Dokumentationen wurde auf Ubuntu bionic verwiesen, das inzwischen End-of-Life ist. Paketnamen unterscheiden sich je nach Ubuntu-Release. Zum Beispiel: libgcc-8-dev heißt jetzt libgcc-s1 und libstdc++-8-dev jetzt libstdc++6. Wenn Sie ein anderes Basis-Image verwenden, prüfen Sie die Paketliste entsprechend.

​
Siehe auch

Installation des Licensing Service unter Linux Lizenzierung Aktivierung