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

# Ejecución de FRE 12 en contenedores Docker en Linux

> Ejecute ABBYY FineReader Engine 12 en contenedores Docker en Linux mediante configuraciones de contenedor único o de dos contenedores en ubuntu:noble, con compatibilidad con licencias en línea y licencias locales.

En este tema se describe cómo ejecutar ABBYY FineReader Engine 12 en contenedores Docker en Linux.

En este tema se tratan dos opciones de configuración:

| Opción                                                     | Descripción                                                                                                                                                                                                                                       |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [**Contenedor único**](#setup-option-1-—-single-container) | El servicio de licencias y el worker de FRE se empaquetan juntos. <br /><br />Más simple; adecuado para pruebas, demostraciones y trabajos de OCR puntuales.                                                                                      |
| [**Dos contenedores**](#setup-option-2-—-two-containers)   | El servicio de licencias y el worker de FRE se ejecutan en contenedores separados. <br /><br />Mejor tolerancia a fallos; si uno se bloquea, puede reiniciarse sin interrumpir el otro. Varios workers pueden compartir un servicio de licencias. |

Ambas opciones de configuración admiten **licencias en línea** y **licencias locales**, y ambas se basan en `ubuntu:noble` (24.04 LTS).

<div id="license-types">
  ## Tipos de licencias
</div>

FRE 12 admite dos tipos de licencias: en línea y local. Ambos tipos funcionan tanto en configuraciones de uno como de dos contenedores, pero tienen distintos requisitos de activación y de tiempo de ejecución.

<div id="online-license">
  ### Licencia en línea
</div>

<Accordion title="Detalles de la licencia en línea">
  * Patrón de nombre de archivo: `XXXXXXXXXXXXXXXXXXXX.ABBYY.ActivationToken`
  * Se valida con `*.abbyy.com` **en tiempo de ejecución**: cada ejecución del contenedor requiere acceso a Internet.
  * Requisitos en cualquier entorno donde esté instalado el servicio de licencias:
    * Conexión activa a Internet
    * Conexión HTTPS saliente permitida (puerto 443) a `*.abbyy.com`
    * GoDaddy Trusted Root CA en el paquete del sistema `ca-certificates` (ya incluido en `ubuntu:noble`)
  * Una sola instancia del servicio de licencias puede funcionar con solo **una** licencia en línea a la vez.
</Accordion>

<div id="local-license">
  ### Licencia local
</div>

<Accordion title="Detalles de la licencia local">
  * Patrón del nombre de archivo: `XXXX-XXXX-XXXX-XXXX-XXXX-XXXX.ABBYY.LocalLicense`
  * Se activa **en tiempo de compilación** durante la instalación de FRE y luego se integra en la imagen.
  * No se requiere Internet en tiempo de ejecución — ideal para entornos aislados de la red.
</Accordion>

<div id="getting-started">
  ## Primeros pasos
</div>

Para usar cualquiera de las opciones de configuración de esta guía, necesitará lo siguiente:

* Docker y Docker Compose instalados (sintaxis v2 de `docker compose`)
* Instalador de ABBYY FineReader Engine 12 para Linux: `FRE*.sh`
* Archivo de licencia (`.ABBYY.ActivationToken` o `.ABBYY.LocalLicense`) y contraseña

***

<div id="setup-option-1-single-container">
  ## Opción de configuración 1 — Contenedor único
</div>

<Accordion title="Detalles del contenedor único">
  Esta opción ejecuta el servicio de licencias y el worker de FRE en un único container. El punto de entrada inicia el servicio de licencias en segundo plano, espera brevemente a que esté listo, ejecuta el sample de CLI, imprime la salida y detiene correctamente todos los procesos al salir.

  Recomendado para pruebas locales, demostraciones y trabajos de CI donde solo se necesita un comando para iniciar y detener el servicio.

  ### Archivos

  Cree un directorio vacío y añada los siguientes archivos:

  * `Dockerfile` — crea la imagen combinada (que se indica a continuación)
  * `entrypoint.sh` — inicia el LS, ejecuta el ejemplo de la CLI y muestra el resultado (a continuación)
  * `docker-compose.yml` — crea y ejecuta el contenedor (indicado a continuación)
  * `.env` — contiene el nombre del archivo de licencia y la contraseña (se indican a continuación)

  ### Compilar y ejecutar

  1. Copia el instalador `FRE*.sh` y el archivo de licencia en el directorio que creaste anteriormente.
  2. Cree un archivo `.env` con los valores de la licencia (consulte más abajo).
  3. Desde ese directorio, ejecute el siguiente comando para crear la imagen e iniciar el contenedor:

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

  El ejemplo de CLI procesará el archivo `Demo.tif` incluido mediante Reconocimiento óptico de caracteres (OCR) e imprimirá el texto reconocido en la consola.

  ### `.env`

  ```env theme={null}
  # Para una licencia local:
  LICENSE_FILE=XXXX-XXXX-XXXX-XXXX-XXXX-XXXX.ABBYY.LocalLicense
  # Para una licencia en línea:
  # 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` es obligatorio. FRE utiliza memoria compartida POSIX y los 64 MB predeterminados de `/dev/shm` no son suficientes. No elimine ni cambie esta configuración.</Warning>

  ### `Dockerfile`

  Esta es una compilación en dos etapas:

  * La etapa 1 usa `gcc:8` para instalar FRE y compilar el ejemplo de la CLI.
  * La etapa 2 crea una imagen de runtime mínima basada en `ubuntu:noble` y copia en ella los binarios del servicio de licencias, el runtime de FRE, el ejemplo compilado y el archivo de licencia.

  ```dockerfile theme={null}
  # Etapa 1: Instalar FRE y compilar el ejemplo de 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

  # Eliminar la biblioteca exclusiva para desarrolladores (no necesaria en tiempo de ejecución)
  RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so

  # Etapa 2: Imagen de tiempo de ejecución mínima con el servicio de licencias y 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/*

  # Copiar el servicio de licencias
  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/

  # Copiar los binarios y datos de tiempo de ejecución de FRE
  COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
  COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data

  # Copiar el archivo de licencia (compatible con .ActivationToken y .LocalLicense)
  COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.* /var/lib/ABBYY/SDK/12/Licenses/

  # Copiar el ejemplo de CLI compilado y la imagen de demostración
  COPY --from=builder /opt/ABBYY/FREngine12/Samples/CommandLineInterface/CommandLineInterface /app/
  COPY --from=builder /opt/ABBYY/FREngine12/Samples/SampleImages/Demo.tif /app/

  # Crear el directorio de trabajo de licencias
  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

  # Iniciar el servicio de licencias en segundo plano
  /usr/local/bin/ABBYY/SDK/12/Licensing/LicensingService /standalone &
  LS_PID=$!

  # Esperar a que el servicio de licencias esté listo
  sleep 2

  # Ejecutar el ejemplo de 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

  # Mostrar el contenido del archivo de salida
  cat ${1##*-of}
  echo "Done"

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

***

<div id="setup-option-2-two-containers">
  ## Opción de configuración 2 — Dos contenedores
</div>

<Accordion title="Detalles de ambos contenedores">
  Esta opción ejecuta el servicio de licencias y el worker de FRE en contenedores separados en una red compartida de Docker Compose. El worker se comunica con el servicio de licencias a través de TCP en `ls:3023`.

  **Recomendado para implementaciones en producción.** Ejecutar los servicios en contenedores separados permite que Docker reinicie cualquiera de ellos de forma independiente si se produce un fallo. Además, permite que varios workers se conecten al mismo servicio de licencias.

  <Warning>
    {" "}

    No ejecute varias réplicas de worker con un solo servicio de licencias, a menos que su licencia lo permita. Una única instancia del servicio de licencias admite solo una licencia en línea a la vez.{" "}
  </Warning>

  ### Archivos

  Cree un directorio vacío y añada los siguientes archivos:

  * `Dockerfile_ls` — crea el contenedor del servicio de licencias (que aparece a continuación)
  * `Dockerfile_worker` — compila el contenedor del worker de FRE (indicado a continuación)
  * `entrypoint.sh` — ejecuta el ejemplo de CLI en el worker (que se muestra a continuación)
  * `docker-compose.yml` — conecta ambos contenedores (indicados a continuación)
  * `.env` — contiene el nombre del archivo de licencia y la contraseña (con el mismo formato que en la Configuración 1)

  ### Compilar y ejecutar

  1. Copia el instalador `FRE*.sh` y el archivo de licencia en el directorio.
  2. Crea un archivo `.env` con los valores de tu licencia.
  3. En ese directorio, ejecute:

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

  Ambos contenedores se compilan e inician. El servicio de licencias arranca primero, seguido del worker, que ejecuta el ejemplo de CLI con el archivo `Demo.tif` incluido e imprime el resultado.

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

  Algunos aspectos a tener en cuenta:

  * El worker usa `depends_on: [ls]`, por lo que el contenedor del servicio de licencias se iniciará antes.
  * Ambos servicios usan `restart: on-failure`, lo que les permite reiniciarse de forma independiente.
  * El argumento de compilación `service_address` del worker es `ls:3023` — el DNS integrado de Docker Compose hace que `ls` apunte al contenedor del servicio de licencias.
  * `shm_size: 1g` se configura en el worker, no en el servicio de licencias, ya que FRE requiere memoria compartida.

  ### `Dockerfile_ls`

  Esta es una compilación en dos etapas:

  * En la etapa 1, se ejecuta el instalador de FRE con `--skip-local-license-activation` para extraer los binarios del servicio de licencias.
  * La etapa 2 crea una imagen mínima de ejecución `ubuntu:noble`, expone el puerto `3023` y ejecuta `LicensingService /standalone` como PID 1. La marca `/standalone` mantiene el servicio de licencias en primer plano, que es el enfoque correcto en Docker (un proceso en primer plano registra los mensajes en stdout y finaliza correctamente cuando se detiene el contenedor).

  ```dockerfile theme={null}
  # Etapa 1: Extraer el servicio de licencias del instalador de 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

  # Etapa 2: Runtime mínimo para el servicio de licencias
  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`

  Esta es una compilación en dos etapas:

  * La etapa 1 instala FRE con `--developer-install` y `--service-address` configurado para apuntar al contenedor del servicio de licencias, y luego compila el sample de CLI.
  * La etapa 2 crea una imagen de runtime mínima de `ubuntu:noble` que contiene solo los binarios de FRE, el ejemplo compilado y la imagen de demostración. Como el worker se comunica con el contenedor `ls` por la red, no se incluyen binarios del servicio de licencias.

  ```dockerfile theme={null}
  # Etapa 1: Instalar FRE y compilar el ejemplo de 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

  # Eliminar la biblioteca exclusiva para desarrolladores (no necesaria en tiempo de ejecución)
  RUN rm /opt/ABBYY/FREngine12/Bin/libProtection.Developer.so

  # Etapa 2: Imagen de runtime mínima
  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/*

  # Copiar los binarios y datos de runtime de FRE
  COPY --from=builder /opt/ABBYY/FREngine12/Bin /opt/ABBYY/FREngine12/Bin
  COPY --from=builder /opt/ABBYY/FREngine12/Data /opt/ABBYY/FREngine12/Data

  # Copiar el archivo de licencia (compatible con .ActivationToken y .LocalLicense)
  COPY --from=builder /var/lib/ABBYY/SDK/12/Licenses/*.ABBYY.* /var/lib/ABBYY/SDK/12/Licenses/

  # Copiar el ejemplo de CLI compilado y la imagen de demostración
  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`

  El punto de entrada del worker es más sencillo que el de la versión de contenedor único, ya que no gestiona el servicio de licencias. El worker simplemente ejecuta el sample e imprime la salida.

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

  # Ejecutar el ejemplo de CLI con los argumentos proporcionados
  /app/CommandLineInterface $1

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

  # Mostrar el contenido del archivo de salida
  cat ${1##*-of}
  echo "Done"
  ```
</Accordion>

***

<div id="customizing-the-cli-sample">
  ## Personalización del ejemplo de CLI
</div>

Ambas opciones de configuración ejecutan el mismo comando predeterminado en `docker-compose.yml`:

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

* `-if` — archivo de entrada
* `-f` — perfil de formato de salida
* `-of` — archivo de salida

<Note>
  Edite esta línea para que apunte a un archivo de entrada o de salida, o a un perfil de formato diferente. Consulte la documentación de FRE Code Samples Library para ver la lista completa de argumentos de la CLI.
</Note>

Para ejecutar Reconocimiento óptico de caracteres (OCR) en sus propios archivos, monte un directorio del host en `/app` y haga que `-if`/`-of` apunten a archivos dentro de él.

***

<div id="common-issues">
  ## Problemas comunes
</div>

A continuación se indican problemas conocidos que se aplican a ambas opciones de configuración:

* **`shm_size: 1g` es obligatorio.** FRE depende de la memoria compartida POSIX y la asignación predeterminada de 64 MB de `/dev/shm` no es suficiente. Los archivos de Compose anteriores ya lo configuran en el servicio worker.
* **El instalador y el archivo de licencia deben estar en el contexto de compilación.** Ambos Dockerfiles hacen `COPY` de `FRE*.sh` y del archivo de licencia; si no están en el directorio desde el que se compila, la compilación falla de inmediato. No monte la licencia en tiempo de ejecución. Se activa durante la compilación.
* **Las licencias en línea necesitan conectividad de salida a la red desde el builder *y* el tiempo de ejecución.** El builder la necesita para activar la licencia; el servicio de licencias del tiempo de ejecución la necesita para seguir validándola.
* **No haga commit de archivos de licencia ni de instaladores.** En el control de código fuente, agregue `.env`, `*.ABBYY.*` y `FRE*.sh` a su lista de ignorados, y no los incluya en ninguna imagen publicada a menos que comprenda las implicaciones y los riesgos.
* **Estos ejemplos usan `ubuntu:noble` (24.04 LTS).** La documentación anterior hacía referencia a Ubuntu bionic, que ya no tiene soporte. Los nombres de los paquetes difieren entre versiones de Ubuntu. Por ejemplo: `libgcc-8-dev` ahora es `libgcc-s1` y `libstdc++-8-dev` ahora es `libstdc++6`. Si usa una imagen base diferente, verifique la lista de paquetes según corresponda.

***

<div id="see-also">
  ## Consulte también
</div>

[Instalación del servicio de licencias en Linux](/es/fine-reader/engine/distribution/distribution-linux/activating-the-library-linux/installing-the-licensing-service-on-linux)

[Licencias](/es/fine-reader/engine/licensing)

[Activación](/es/fine-reader/engine/licensing/activation)