> ## 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.

# Ausführen von FRE 12 in Docker-Containern unter Linux

> Führen Sie ABBYY FineReader Engine 12 unter Linux in Docker-Containern aus – mit Setups mit einem oder zwei Containern auf ubuntu:noble sowie Unterstützung für Online- und lokale Lizenzen.

Dieses Thema beschreibt, wie Sie ABBYY FineReader Engine 12 in Docker-Containern unter Linux ausführen.

In diesem Thema werden zwei Einrichtungsoptionen behandelt:

| Option                                                        | Beschreibung                                                                                                                                                                                                                                     |
| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [**Einzelner Container**](#setup-option-1-—-single-container) | Licensing Service und FRE-Worker zusammen in einem Container gebündelt. <br /><br />Einfacher; gut für Tests, Demos und einmalige OCR-Jobs.                                                                                                      |
| [**Zwei Container**](#setup-option-2-—-two-containers)        | Licensing Service und FRE-Worker in separaten Containern. <br /><br />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).

<div id="license-types">
  ## Lizenztypen
</div>

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.

<div id="online-license">
  ### Online-Lizenz
</div>

<Accordion title="Details zur 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.
</Accordion>

<div id="local-license">
  ### Lokale Lizenz
</div>

<Accordion title="Details zur lokalen 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.
</Accordion>

<div id="getting-started">
  ## Erste Schritte
</div>

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

***

<div id="setup-option-1-single-container">
  ## Einrichtungsoption 1 — Einzelner Container
</div>

<Accordion title="Details zum einzelnen 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:

     ```bash theme={null}
     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`

  ```env theme={null}
  # 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`

  ```yaml theme={null}
  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"]
  ```

  <Warning>
    {" "}

    `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.
  </Warning>

  ### `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.

  ```dockerfile theme={null}
  # 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`

  ```bash theme={null}
  #!/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
  ```
</Accordion>

***

<div id="setup-option-2-two-containers">
  ## Einrichtungsoption 2 — Zwei Container
</div>

<Accordion title="Details zu den beiden Containern">
  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.

  <Warning>
    {" "}

    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.{" "}
  </Warning>

  ### 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:

     ```bash theme={null}
     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`

  ```yaml theme={null}
  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).

  ```dockerfile theme={null}
  # 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.

  ```dockerfile theme={null}
  # 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.

  ```bash theme={null}
  #!/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"
  ```
</Accordion>

***

<div id="customizing-the-cli-sample">
  ## Anpassen des CLI-Beispiels
</div>

Beide Einrichtungsoptionen führen denselben Standardbefehl in `docker-compose.yml` aus:

```yaml theme={null}
command: ["-if /app/Demo.tif -f TextUnicodeDefaults -of /app/Test.txt"]
```

* `-if` — Eingabedatei
* `-f` — Ausgabeformatprofil
* `-of` — Ausgabedatei

<Note>
  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.
</Note>

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.

***

<div id="common-issues">
  ## Häufige Probleme
</div>

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 `COPY`en `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.

***

<div id="see-also">
  ## Siehe auch
</div>

[Installation des Licensing Service unter Linux](/de/fine-reader/engine/distribution/distribution-linux/activating-the-library-linux/installing-the-licensing-service-on-linux)

[Lizenzierung](/de/fine-reader/engine/licensing)

[Aktivierung](/de/fine-reader/engine/licensing/activation)