# Exportar binarios


¿Sabías que puedes usar Docker para compilar tu aplicación en binarios independientes?
A veces, no quieres empaquetar y distribuir tu aplicación como una imagen de Docker.
Usa Docker para compilar tu aplicación y utiliza exportadores para guardar el resultado en el disco.

El formato de salida predeterminado para `docker build` es una imagen de contenedor. Esa imagen se
carga automáticamente en tu almacenamiento local de imágenes, donde puedes ejecutar un contenedor
a partir de ella o subirla a un registro. Internamente, esto utiliza el exportador predeterminado,
llamado exportador `docker`.

Para exportar los resultados de tu compilación como archivos, puedes usar la opción `--output`
(o `-o` para abreviar). La opción `--output` te permite cambiar el formato de salida de
tu compilación.

## Exportar binarios desde una compilación

Si especificas una ruta de archivo en la opción `--output` de `docker build`, Docker exporta
el contenido del contenedor de compilación al final del proceso a la ubicación especificada
en el sistema de archivos de tu host. Esto utiliza el [exportador local](/build/exporters/local-tar/).

Lo interesante de esto es que puedes usar el potente aislamiento y las características de
compilación de Docker para crear binarios independientes. Esto funciona muy bien para Go,
Rust y otros lenguajes que pueden compilarse en un único binario.

El siguiente ejemplo crea un programa simple en Rust que imprime "Hello, World!" y exporta
el binario al sistema de archivos del host.

1. Crea un nuevo directorio para este ejemplo y accede a él:

   ```console
   $ mkdir hello-world-bin
   $ cd hello-world-bin
   ```

2. Crea un Dockerfile con el siguiente contenido:

   ```Dockerfile
   # syntax=docker/dockerfile:1
   FROM rust:alpine AS build
   WORKDIR /src
   COPY <<EOT hello.rs
   fn main() {
       println!("Hello World!");
   }
   EOT
   RUN rustc -o /bin/hello hello.rs
   
   FROM scratch
   COPY --from=build /bin/hello /
   ENTRYPOINT ["/hello"]
   ```

   > [!TIP]
   > La sintaxis `COPY <<EOT` es un [here-document](/reference/dockerfile/#here-documents).
   > Te permite escribir cadenas multilínea en un Dockerfile. Aquí se utiliza para
   > crear un programa Rust simple directamente en el Dockerfile.

   Este Dockerfile utiliza una compilación multi-etapa para compilar el programa en la primera
   etapa y luego copia el binario a una imagen scratch en la segunda. La
   imagen final es una imagen mínima que solo contiene el binario. Este caso de uso
   para la imagen `scratch` es común para crear artefactos de compilación mínimos para
   programas que no requieren un sistema operativo completo para ejecutarse.

3. Compila el Dockerfile y exporta el binario al directorio de trabajo actual:

   ```console
   $ docker build --output=. .
   ```

   Este comando compila el Dockerfile y exporta el binario al directorio de
   trabajo actual. El binario se llama `hello` y se crea en el directorio
   de trabajo actual.

## Exportar compilaciones multiplataforma

Puedes usar el exportador `local` para exportar binarios en combinación con
[compilaciones multiplataforma](/build/building/multi-platform/). Esto te permite
compilar múltiples binarios a la vez, que pueden ejecutarse en cualquier máquina de cualquier
arquitectura, siempre que la plataforma de destino sea compatible con el compilador que utilices.

Continuando con el Dockerfile de ejemplo de la sección
[Exportar binarios desde una compilación](#exportar-binarios-desde-una-compilación):

```dockerfile
# syntax=docker/dockerfile:1
FROM rust:alpine AS build
WORKDIR /src
COPY <<EOT hello.rs
fn main() {
    println!("Hello World!");
}
EOT
RUN rustc -o /bin/hello hello.rs

FROM scratch
COPY --from=build /bin/hello /
ENTRYPOINT ["/hello"]
```

Puedes compilar este programa de Rust para múltiples plataformas utilizando la opción `--platform`
con el comando `docker build`. En combinación con la opción `--output`, la compilación exporta
los binarios para cada destino al directorio especificado.

Por ejemplo, para compilar el programa tanto para `linux/amd64` como para `linux/arm64`:

```console
$ docker build --platform=linux/amd64,linux/arm64 --output=out .
$ tree out/
out/
├── linux_amd64
│   └── hello
└── linux_arm64
    └── hello

3 directories, 2 files
```

## Información adicional

Además del exportador `local`, hay otros exportadores disponibles. Para obtener
más información sobre los exportadores disponibles y cómo utilizarlos, consulta la
documentación de [exportadores](/build/exporters/).