# docker image import

**Descripción:** Importa los contenidos de un archivo tar para crear una imagen del sistema de archivos

**Uso:** `docker image import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]`

**Alias:** `docker import`








## Descripción

Puedes especificar una `URL` o `-` (guion) para tomar datos directamente de `STDIN`. La
`URL` puede apuntar a un archivo (.tar, .tar.gz, .tgz, .bzip, .tar.xz o .txz)
que contenga un sistema de archivos o a un archivo individual en el host Docker. Si
especificas un archivo comprimido, Docker lo descomprime en el contenedor de forma relativa a `/`
(raíz). Si especificas un archivo individual, debes especificar la ruta completa dentro
del host. Para importar desde una ubicación remota, especifica un `URI` que comience con el
protocolo `http://` o `https://`.


## Opciones

| Opción                                                        | Predeterminado                                        | Descripción                                                                                                                                    |
| ------------------------------------------------------------- | ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|  | `-c`, `--change` |  |  Aplica la instrucción de Dockerfile a la imagen creada |

 | `-m`, `--message` |  |  Establece el mensaje de commit para la imagen importada |

 | `--platform` |  | API 1.32+ Establece la plataforma si el servidor tiene capacidad multiplataforma |




## Ejemplos

### Importar desde una ubicación remota

Esto crea una nueva imagen sin etiqueta.

```console
$ docker import https://example.com/exampleimage.tgz
```

### Importar desde un archivo local

Importar a docker mediante pipe y `STDIN`.

```console
$ cat exampleimage.tgz | docker import - exampleimagelocal:new
```

Importar a docker desde un archivo local.

```console
$ docker import /path/to/exampleimage.tgz
```

### Importar desde un directorio local

```console
$ sudo tar -c . | docker import - exampleimagedir
```

Ten en cuenta el `sudo` en este ejemplo: debes preservar
la propiedad de los archivos (especialmente la propiedad de root) durante el
archivado con tar. Si no eres root (o no usas el comando sudo) al hacer
el tar, es posible que las propiedades no se preserven.

### Importar con nuevas configuraciones (-c, --change) {#change}

La opción `--change` aplica instrucciones de `Dockerfile` a la imagen que es
creada. No todas las instrucciones de `Dockerfile` son compatibles; la lista de instrucciones
está limitada a cambios de metadatos (configuración). Se admiten las siguientes instrucciones
de `Dockerfile`:

- [`CMD`](/reference/dockerfile/#cmd)
- [`ENTRYPOINT`](/reference/dockerfile/#entrypoint)
- [`ENV`](/reference/dockerfile/#env)
- [`EXPOSE`](/reference/dockerfile/#expose)
- [`HEALTHCHECK`](/reference/dockerfile/#healthcheck)
- [`LABEL`](/reference/dockerfile/#label)
- [`ONBUILD`](/reference/dockerfile/#onbuild)
- [`STOPSIGNAL`](/reference/dockerfile/#stopsignal)
- [`USER`](/reference/dockerfile/#user)
- [`VOLUME`](/reference/dockerfile/#volume)
- [`WORKDIR`](/reference/dockerfile/#workdir)

El siguiente ejemplo importa una imagen de un archivo TAR que contiene un sistema de archivos raíz,
y establece la variable de entorno `DEBUG` en la imagen resultante:

```console
$ docker import --change "ENV DEBUG=true" ./rootfs.tgz exampleimagedir
```

La opción `--change` se puede configurar varias veces para aplicar múltiples instrucciones
de `Dockerfile`. El ejemplo de abajo establece las etiquetas `LABEL1` y `LABEL2` en
la imagen importada, además de la variable de entorno `DEBUG` del
ejemplo anterior:

```console
$ docker import \
    --change "ENV DEBUG=true" \
    --change "LABEL LABEL1=hello" \
    --change "LABEL LABEL2=world" \
    ./rootfs.tgz exampleimagedir
```

### Importar con un mensaje de commit (-m, --message) {#message}

La opción `--message` (o `-m`) te permite establecer un comentario personalizado en
los metadatos de la imagen. El siguiente ejemplo importa una imagen desde un archivo local
y establece un mensaje personalizado.

```console
$ docker import --message "New image imported from tarball" ./rootfs.tgz exampleimagelocal:new
sha256:25e54c0df7dc49da9093d50541e0ed4508a6b78705057f1a9bebf1d564e2cb00
```

Después de importar, el mensaje se establece en el campo "Comment" de la configuración de
la imagen, que se muestra al ver el historial de la imagen:

```console
$ docker image history exampleimagelocal:new

IMAGE          CREATED         CREATED BY   SIZE      COMMENT
25e54c0df7dc   2 minutes ago                53.6MB    New image imported from tarball
```

### Cuando el demonio admite múltiples sistemas operativos

Si el demonio admite múltiples sistemas operativos y la imagen que se está importando
no coincide con el sistema operativo predeterminado, puede ser necesario añadir
`--platform`. Esto sería necesario al importar una imagen de Linux en un demonio de
Windows.

```console
$ docker import --platform=linux .\linuximage.tar
```

### Establecer la plataforma para la imagen importada (--platform) {#platform}

La opción `--platform` te permite especificar la plataforma para la imagen importada.
Por defecto, se utiliza la plataforma nativa del demonio, pero la opción
`--platform` te permite invalidar este valor por defecto, por ejemplo, en
situaciones donde el sistema de archivos raíz importado es para una arquitectura
o sistema operativo diferente.

La opción de plataforma toma el formato `os[/arch[/variant]]`; por ejemplo,
`linux/amd64` o `linux/arm64/v8`. La arquitectura y la variante son opcionales
y, si se omiten, toman como valor predeterminado la arquitectura nativa del demonio.

El siguiente ejemplo importa una imagen de un sistema de archivos raíz en `rootfs.tgz`,
y establece la plataforma de la imagen a `linux/amd64`:

```console
$ docker image import --platform=linux/amd64  ./rootfs.tgz imported:latest
sha256:44a8b44157dad5edcff85f0c93a3e455f3b20a046d025af4ec50ed990d7ebc09
```

Después de importar la imagen, la plataforma de la imagen se establece en su configuración:

```console
$ docker image inspect --format '{{.Os}}/{{.Architecture}}' imported:latest
linux/amd64
```



