# Exportadores local y tar


Los exportadores `local` y `tar` generan el sistema de archivos raíz del resultado de la compilación en un directorio local. Son útiles para producir artefactos que no son imágenes de contenedor.

- `local` exporta archivos y directorios.
- `tar` exporta lo mismo, pero empaqueta la exportación en un archivo tar.

## Sinopsis

Compila utilizando los exportadores `local` y `tar`:

```console
$ docker buildx build --output type=local[,parameters] .
$ docker buildx build --output type=tar[,parameters] .
```

La siguiente tabla describe los parámetros disponibles:

| Parámetro | Tipo | Predeterminado | Descripción |
| ---------------- | ------- | ------- | --------------------------------------------------------------------------------- |
| `dest`           | String  |         | Ruta a la que copiar los archivos |
| `platform-split` | Boolean | `true`  | Solo para el exportador `local`. Divide las salidas multi-plataforma en subdirectorios de plataforma. |

## Compilaciones multi-plataforma con el exportador local

El parámetro `platform-split` controla cómo se organizan las salidas de compilación multi-plataforma.

Considera este Dockerfile que crea archivos específicos de la plataforma:

```dockerfile
FROM busybox AS build
ARG TARGETOS
ARG TARGETARCH
RUN mkdir /out && echo foo > /out/hello-$TARGETOS-$TARGETARCH

FROM scratch
COPY --from=build /out /
```

### Dividir por plataforma (predeterminado)

Por defecto, el exportador local crea un subdirectorio separado para cada plataforma:

```console
$ docker buildx build \
  --platform linux/amd64,linux/arm64 \
  --output type=local,dest=./output \
  .
```

Esto produce la siguiente estructura de directorios:

```text
output/
├── linux_amd64/
│   └── hello-linux-amd64
└── linux_arm64/
    └── hello-linux-arm64
```

### Fusionar todas las plataformas

Para fusionar archivos de todas las plataformas en el mismo directorio, establece `platform-split=false`:

```console
$ docker buildx build \
  --platform linux/amd64,linux/arm64 \
  --output type=local,dest=./output,platform-split=false \
  .
```

Esto produce una estructura de directorios plana:

```text
output/
├── hello-linux-amd64
└── hello-linux-arm64
```

Los archivos de todas las plataformas se fusionan en un único directorio. Si múltiples plataformas producen archivos con nombres idénticos, la exportación fallará con un error.

### Compilaciones de una sola plataforma

Las compilaciones de una sola plataforma se exportan directamente al directorio de destino sin crear un subdirectorio de plataforma:

```console
$ docker buildx build \
  --platform linux/amd64 \
  --output type=local,dest=./output \
  .
```

Esto produce:

```text
output/
└── hello-linux-amd64
```

Para incluir el subdirectorio de plataforma incluso en compilaciones de una sola plataforma, establece explícitamente `platform-split=true`:

```console
$ docker buildx build \
  --platform linux/amd64 \
  --output type=local,dest=./output,platform-split=true \
  .
```

Esto produce:

```text
output/
└── linux_amd64/
    └── hello-linux-amd64
```

## Lectura adicional

Para obtener más información sobre los exportadores `local` o `tar`, consulta el [README de BuildKit](https://github.com/moby/buildkit/blob/master/README.md#local-directory).