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

# Exécuter FRE 12 dans des conteneurs Docker sous Linux

> Exécutez ABBYY FineReader Engine 12 dans des conteneurs Docker sous Linux à l’aide d’une configuration à conteneur unique ou à deux conteneurs sur ubuntu:noble, avec prise en charge des licences en ligne et locales.

Cette rubrique explique comment exécuter ABBYY FineReader Engine 12 dans des conteneurs Docker sous Linux.

Cette rubrique présente deux options de configuration :

| Option                                                     | Description                                                                                                                                                                                                                                                    |
| ---------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [**Conteneur unique**](#setup-option-1-—-single-container) | Le service de licence et le worker FRE sont regroupés dans un même conteneur. <br /><br />Plus simple ; convient bien aux tests, aux démonstrations et aux tâches d’OCR ponctuelles.                                                                           |
| [**Deux conteneurs**](#setup-option-2-—-two-containers)    | Le service de licence et le worker FRE sont répartis dans des conteneurs distincts. <br /><br />Meilleure tolérance aux pannes ; si l’un s’arrête, il peut redémarrer sans interrompre l’autre. Plusieurs workers peuvent partager un même service de licence. |

Les deux options de configuration prennent en charge les **licences en ligne** et les **licences locales**, et s’appuient toutes deux sur `ubuntu:noble` (24.04 LTS).

<div id="license-types">
  ## Types de licence
</div>

FRE 12 accepte deux types de licences : en ligne et locales. Les deux types fonctionnent aussi bien dans les configurations à un conteneur que dans celles à deux conteneurs, mais leurs exigences en matière d’activation et d’exécution diffèrent.

<div id="online-license">
  ### Licence en ligne
</div>

<Accordion title="Détails de la licence en ligne">
  * Modèle de nom de fichier : `XXXXXXXXXXXXXXXXXXXX.ABBYY.ActivationToken`
  * Validation auprès de `*.abbyy.com` **à l’exécution** — chaque démarrage du conteneur nécessite un accès à Internet.
  * Exigences partout où le service de licence est installé :
    * Connexion Internet active
    * Connexions HTTPS sortantes autorisées (port 443) vers `*.abbyy.com`
    * GoDaddy Trusted Root CA dans le package système `ca-certificates` (déjà présent dans `ubuntu:noble`)
  * Une instance unique du service de licence ne peut fonctionner qu’avec **une** seule licence en ligne à la fois.
</Accordion>

<div id="local-license">
  ### Licence locale
</div>

<Accordion title="Détails de la licence locale">
  * Schéma de nom de fichier : `XXXX-XXXX-XXXX-XXXX-XXXX-XXXX.ABBYY.LocalLicense`
  * Activée **lors de la génération de l’image** pendant l’installation de FRE, puis intégrée à l’image.
  * Pas besoin d’accès à Internet à l’exécution — idéal pour les environnements isolés du réseau.
</Accordion>

<div id="getting-started">
  ## Prise en main
</div>

Pour utiliser l’une ou l’autre des options d’installation de ce guide, vous aurez besoin de :

* Docker et Docker Compose installés (syntaxe `docker compose` v2)
* Installateur Linux d’ABBYY FineReader Engine 12 : `FRE*.sh`
* Fichier de licence (`.ABBYY.ActivationToken` ou `.ABBYY.LocalLicense`) et mot de passe

***

<div id="setup-option-1-single-container">
  ## Option de configuration 1 — Conteneur unique
</div>

<Accordion title="Détails de l’option à conteneur unique">
  Cette option exécute le service de licence et le worker FRE dans un seul conteneur. Le point d'entrée démarre le service de licence en arrière-plan, attend brièvement qu'il soit opérationnel, exécute l'exemple CLI, affiche la sortie et arrête proprement tous les processus à la fermeture.

  Recommandé pour les tests locaux, les démonstrations et les jobs CI où une seule commande suffit pour démarrer et arrêter.

  ### Fichiers

  Créez un répertoire vide et ajoutez les fichiers suivants :

  * `Dockerfile` — génère l’image combinée (indiquée ci-dessous)
  * `entrypoint.sh` — démarre le LS, exécute l’exemple CLI, affiche le résultat (ci-dessous)
  * `docker-compose.yml` — crée et exécute le conteneur (indiqué ci-dessous)
  * `.env` — contient le nom du fichier de licence et votre mot de passe (indiqués ci-dessous)

  ### Compiler et exécuter

  1. Copiez votre installateur `FRE*.sh` et votre fichier de licence dans le répertoire que vous avez créé ci-dessus.
  2. Créez un fichier `.env` avec les informations de votre licence (voir ci-dessous).
  3. Depuis ce répertoire, exécutez la commande suivante pour générer l’image et démarrer le conteneur :

     ```bash theme={null}
     docker compose up
     ```

  Le sample CLI traite le fichier `Demo.tif` fourni à l'aide de la reconnaissance optique de caractères (OCR) et affiche le texte reconnu dans la console.

  ### `.env`

  ```env theme={null}
  # Pour une licence locale :
  LICENSE_FILE=XXXX-XXXX-XXXX-XXXX-XXXX-XXXX.ABBYY.LocalLicense
  # Pour une licence en ligne :
  # 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` est obligatoire. FRE utilise la mémoire partagée POSIX et les 64 Mo par défaut de `/dev/shm` sont insuffisants. Ne supprimez pas ce paramètre et ne le modifiez pas.</Warning>

  ### `Dockerfile`

  Il s'agit d'un build en deux étapes :

  * L’étape 1 utilise `gcc:8` pour installer FRE et compiler l’exemple CLI.
  * L’étape 2 crée une image d’exécution minimale `ubuntu:noble` et y copie les binaires du service de licence, le runtime FRE, l’exemple compilé et le fichier de licence.

  ```dockerfile theme={null}
  # Étape 1 : Installer FRE et compiler l'exemple CLI
  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

  # Supprimer la bibliothèque réservée aux développeurs (inutile à l'exécution)
  RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so

  # Étape 2 : Image d'exécution minimale avec le service de licence et 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/*

  # Copier le service de licence
  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/

  # Copier les binaires et les données d'exécution de FRE
  COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
  COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data

  # Copier le fichier de licence (compatible avec .ActivationToken et .LocalLicense)
  COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.* /var/lib/ABBYY/SDK/12/Licenses/

  # Copier l'exemple CLI 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/

  # Créer le répertoire de travail des licences
  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

  # Démarrer le service de licence en arrière-plan
  /usr/local/bin/ABBYY/SDK/12/Licensing/LicensingService /standalone &
  LS_PID=$!

  # Attendre que le service de licence soit prêt
  sleep 2

  # Exécuter l'exemple CLI
  /app/CommandLineInterface $1

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

  # Afficher le contenu du fichier de sortie
  cat ${1##*-of}
  echo "Done"

  # Nettoyage
  kill $LS_PID 2>/dev/null
  ```
</Accordion>

***

<div id="setup-option-2-two-containers">
  ## Option de configuration 2 — Deux conteneurs
</div>

<Accordion title="Détails sur les deux conteneurs">
  Cette option exécute le service de licence et le worker FRE dans des conteneurs distincts sur un réseau Docker Compose partagé. Le worker communique avec le service de licence via TCP sur `ls:3023`.

  **Recommandé pour les déploiements en production.** L'exécution des services dans des conteneurs distincts permet à Docker de redémarrer l'un ou l'autre indépendamment en cas de défaillance. Cela permet également à plusieurs workers de se connecter au même service de licence.

  <Warning>
    {" "}

    N’exécutez pas plusieurs réplicas de workers sur un même service de licence, sauf si votre licence l’autorise. Une seule instance du service de licence ne prend en charge qu’une seule licence en ligne à la fois.{" "}
  </Warning>

  ### Fichiers

  Créez un répertoire vide et ajoutez les fichiers suivants :

  * `Dockerfile_ls` — crée le conteneur du service de licence (présenté ci-dessous)
  * `Dockerfile_worker` — construit le conteneur worker FRE (répertorié ci-dessous)
  * `entrypoint.sh` — exécute l’exemple CLI dans le worker (répertorié ci-dessous)
  * `docker-compose.yml` — connecte les deux conteneurs (indiqués ci-dessous)
  * `.env` — contient le nom du fichier de licence et le mot de passe (même format que la configuration 1)

  ### Compiler et exécuter

  1. Copiez le fichier d’installation `FRE*.sh` et le fichier de licence dans le répertoire.
  2. Créez un fichier `.env` avec les valeurs de votre licence.
  3. Dans ce répertoire, exécutez :

     ```bash theme={null}
     docker compose up
     ```

  Les deux conteneurs sont construits et démarrés. Le service de licence démarre en premier, suivi du worker, qui exécute l'exemple CLI sur le fichier `Demo.tif` inclus et affiche le résultat.

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

  Quelques points à noter :

  * Le worker utilise `depends_on: [ls]` afin que le conteneur du service de licence démarre en premier.
  * Les deux services utilisent `restart: on-failure`, ce qui leur permet de redémarrer chacun de manière indépendante.
  * L’argument de build `service_address` du worker est `ls:3023` — le DNS intégré de Docker Compose résout `ls` en l’adresse du conteneur du service de licence.
  * `shm_size: 1g` est configuré sur le worker, et non sur le service de licence, car FRE nécessite une mémoire partagée.

  ### `Dockerfile_ls`

  Il s'agit d'un build en deux étapes :

  * L’étape 1 lance le programme d’installation FRE avec `--skip-local-license-activation` pour extraire les fichiers binaires du service de licence.
  * L’étape 2 crée une image d’exécution `ubuntu:noble` minimale, expose le port `3023` et exécute `LicensingService /standalone` en tant que PID 1. L’indicateur `/standalone` maintient le service de licence au premier plan, ce qui est la bonne approche avec Docker (un processus au premier plan écrit ses journaux sur stdout et se termine proprement lorsque le conteneur est arrêté).

  ```dockerfile theme={null}
  # Étape 1 : Extraire le service de licence depuis l'installateur FRE
  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

  # Étape 2 : Runtime minimal pour le service de licence
  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`

  Il s'agit d'un build en deux étapes :

  * L’étape 1 installe FRE avec `--developer-install` et `--service-address` pointant vers le conteneur du service de licence, puis compile l’exemple d’interface de ligne de commande.
  * L’étape 2 crée une image d’exécution `ubuntu:noble` minimale contenant uniquement les binaires FRE, l’exemple compilé et l’image de démonstration. Comme le worker communique avec le conteneur `ls` via le réseau, aucun binaire du service de licence n’est inclus.

  ```dockerfile theme={null}
  # Étape 1 : Installer FRE et compiler l'exemple CLI
  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

  # Supprimer la bibliothèque réservée aux développeurs (inutile à l'exécution)
  RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so

  # Étape 2 : Image d'exécution minimale
  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/*

  # Copier les binaires et les données d'exécution FRE
  COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
  COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data

  # Copier le fichier de licence (compatible avec .ActivationToken et .LocalLicense)
  COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.* /var/lib/ABBYY/SDK/12/Licenses/

  # Copier l'exemple CLI 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
  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`

  Le point d'entrée du worker est plus simple que la version à conteneur unique, car il ne gère pas le service de licence. Le worker exécute simplement le sample et affiche le résultat.

  ```bash theme={null}
  #!/bin/bash

  # Exécuter l'exemple CLI avec les arguments fournis
  /app/CommandLineInterface $1

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

  # Afficher le contenu du fichier de sortie
  cat ${1##*-of}
  echo "Done"
  ```
</Accordion>

***

<div id="customizing-the-cli-sample">
  ## Personnaliser l’exemple CLI
</div>

Les deux options de configuration exécutent la même commande par défaut dans `docker-compose.yml` :

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

* `-if` — fichier d’entrée
* `-f` — profil de format de sortie
* `-of` — fichier de sortie

<Note>
  Modifiez cette ligne pour qu’elle pointe vers un autre fichier d’entrée, fichier de sortie ou profil de format. Consultez la documentation de la FRE Code Samples Library pour obtenir la liste complète des arguments de l’interface CLI.
</Note>

Pour exécuter la Reconnaissance optique de caractères (OCR) sur vos propres fichiers, montez un répertoire hôte dans `/app` à l’aide d’un bind mount et faites pointer `-if`/`-of` vers des fichiers qu’il contient.

***

<div id="common-issues">
  ## Problèmes courants
</div>

Les problèmes connus suivants s’appliquent aux deux options de configuration :

* **`shm_size: 1g` est obligatoire.** FRE s’appuie sur la mémoire partagée POSIX, et l’allocation `/dev/shm` par défaut de 64 Mo est insuffisante. Les fichiers compose ci-dessus définissent déjà ce paramètre pour le service worker.
* **Le programme d’installation et le fichier de licence doivent se trouver dans le contexte de build.** Les deux Dockerfiles copient `FRE*.sh` et le fichier de licence : s’ils ne se trouvent pas dans le répertoire depuis lequel vous lancez le build, celui-ci échoue immédiatement. Ne montez pas la licence à l’exécution. Elle est activée pendant le build.
* **Les licences en ligne nécessitent un accès réseau sortant depuis le builder *et* le runtime.** Le builder en a besoin pour l’activation ; le service de licence du runtime en a besoin pour poursuivre la validation.
* **Ne versionnez pas les fichiers de licence ni les programmes d’installation.** Dans votre système de contrôle de version, ajoutez `.env`, `*.ABBYY.*` et `FRE*.sh` à votre liste d’exclusion, et ne les incluez dans aucune image publiée, sauf si vous comprenez les implications et les risques.
* **Ces exemples utilisent `ubuntu:noble` (24.04 LTS).** La documentation précédente faisait référence à Ubuntu bionic, qui est en fin de vie. Les noms des paquets diffèrent selon les versions d’Ubuntu. Par exemple : `libgcc-8-dev` est maintenant `libgcc-s1` et `libstdc++-8-dev` est maintenant `libstdc++6`. Si vous utilisez une autre image de base, vérifiez la liste des paquets en conséquence.

***

<div id="see-also">
  ## Voir aussi
</div>

[Installation du service de licence sous Linux](/fr/fine-reader/engine/distribution/distribution-linux/activating-the-library-linux/installing-the-licensing-service-on-linux)

[Licence](/fr/fine-reader/engine/licensing)

[Activation](/fr/fine-reader/engine/licensing/activation)