Con docker buildx se construye una sola imagen multiarquitectura de Docker que funciona tanto en un servidor con procesador Intel o AMD (AMD64) como en uno ARM64: un Mac con Apple Silicon, una Raspberry Pi o una instancia ARM en la nube. Por eso es la pieza que falta cuando alguien publica una imagen en su portátil, la despliega en otro equipo y el contenedor se niega a arrancar con un exec format error, o cuando un programa que tarda diez segundos en compilarse pasa a tardar minuto y medio al construirlo para ARM.
Por eso, esta guía de consulta reúne lo que un profesional de TI necesita tener a mano: qué es una imagen multiarquitectura y cómo leer su manifiesto, las tres formas de construirla (emulación con QEMU, compilación cruzada y nodos nativos), cómo hacer un docker build arm64 y AMD64 en una sola orden, qué hacer con las imágenes que solo existen para una arquitectura y cómo resolver los errores más comunes.
Para ello, las órdenes y las cifras salen de un laboratorio propio, ejecutado el 19 de noviembre de 2026 en un portátil de trabajo con Windows 11, un Intel Core i9-13900H, Docker Desktop 29.9.2 y buildx 0.38.1. Además, los comportamientos que no se pudieron reproducir se citan de la documentación oficial de Docker, y así se indica en cada caso.
Docker buildx: la respuesta corta
Si solo tiene un minuto, esta tabla resume las tres formas de construir una imagen para AMD64 y ARM64 desde un equipo AMD64, con el tiempo que medimos al compilar el mismo programa en Go (mediana de tres construcciones sin caché).
| Estrategia | Qué hace | Tiempo medido para ARM64 | Cuándo usarla |
|---|---|---|---|
| Nativa (referencia) | Compila para la misma arquitectura del equipo | 9,8 s (AMD64) | Siempre que se pueda |
| Emulación con QEMU | Ejecuta los pasos de ARM64 traduciendo cada instrucción | 93,7 s | Imágenes sencillas, sin compilación pesada |
| Compilación cruzada | Compila en AMD64 un binario para ARM64 | 8,8 s | Go, Rust, .NET, Java y otros lenguajes que la admiten |
| Nodos nativos | Un equipo ARM64 real construye su parte | No medido (sin equipo ARM) | Compilaciones largas o que fallan emuladas |
En resumen: la emulación es la forma más fácil de empezar, porque no exige cambiar el Dockerfile, pero en nuestro laboratorio hizo la compilación unas diez veces más lenta. Cuando el lenguaje lo permite, la compilación cruzada da el mismo resultado en el tiempo de una compilación nativa.
Por qué una imagen de Docker no funciona en cualquier procesador
Un contenedor no es una máquina virtual: comparte el núcleo del sistema operativo del equipo que lo ejecuta y, por tanto, también su procesador. Así pues, los programas que hay dentro de la imagen tienen que estar compilados para esa arquitectura. Un binario de AMD64 no corre de forma nativa en un procesador ARM64, igual que un programa de Windows no corre en Linux. La guía de AMD64 vs ARM64 explica la diferencia entre las dos familias de procesadores.
Hasta hace poco, casi todo era AMD64 y nadie se lo preguntaba. Hoy, en cambio, ARM64 aparece en sitios muy corrientes de una empresa:
- Portátiles de desarrollo: los Mac con Apple Silicon y los portátiles con Windows en ARM.
- Servidores en la nube: los grandes proveedores ofrecen instancias ARM64, a menudo más baratas por núcleo.
- Equipos pequeños: Raspberry Pi, equipos de red y dispositivos que ejecutan contenedores en sitio.
De ahí viene, precisamente, el problema habitual: una imagen construida en un Mac con Apple Silicon sale para ARM64 y falla en el servidor AMD64 de producción, o al revés. Sin embargo, la solución no es construir dos imágenes con dos nombres distintos, sino una imagen multiarquitectura con un solo nombre.
Qué es docker buildx
En la práctica, docker buildx es el complemento de la línea de órdenes de Docker que construye imágenes con BuildKit, el motor de construcción moderno de Docker. Hoy, en las versiones actuales de Docker Desktop y Docker Engine, la orden docker build ya pasa por buildx, así que muchas personas lo usan sin saberlo. En cambio, la diferencia aparece cuando se necesita algo más: varias plataformas, guardar la caché en otro sitio o construir en otro equipo.
Para eso, buildx trabaja con builders (constructores). Cada builder usa un driver que decide dónde corre BuildKit:
| Driver | Dónde corre BuildKit | Carga la imagen en Docker sola | Imágenes multiarquitectura |
|---|---|---|---|
docker | Dentro del propio motor de Docker | Sí | Sí, con el almacén de imágenes de containerd |
docker-container | En un contenedor aparte | No: hace falta --load o --push | Sí |
kubernetes | En pods de un clúster de Kubernetes | No | Sí |
remote | En un BuildKit que se administra a mano | No | Sí |
cloud | En los constructores de Docker Build Cloud | Según el caso | Sí |
Ojo con un detalle: la tabla de drivers de la documentación de Docker marca que el driver docker no hace imágenes multiarquitectura. Eso es cierto con el almacén de imágenes clásico; sin embargo, la propia documentación aclara que Docker Desktop y Docker Engine 29 o posterior usan de fábrica el almacén de containerd, que sí las admite. En nuestro laboratorio, el builder predeterminado de Docker Desktop construyó, cargó y publicó imágenes para dos arquitecturas sin crear ningún builder nuevo.
Comprobar la versión y los builders de docker buildx
Por eso, antes de nada, conviene saber qué versión hay y qué plataformas sabe construir el builder:
docker buildx version
docker buildx ls
docker buildx inspect desktop-linux
docker info --format "{{.DriverStatus}}"
En el equipo del laboratorio, docker buildx version devolvió github.com/docker/buildx v0.38.1 y docker buildx inspect mostró BuildKit 0.34.0 con estas plataformas: linux/amd64, linux/amd64/v2, linux/amd64/v3, linux/arm64, linux/riscv64, linux/ppc64le, linux/s390x, linux/arm/v7, linux/arm/v6. Por último, docker info confirma el almacén de imágenes: si aparece io.containerd.snapshotter.v1, el equipo usa el de containerd.
Qué es una imagen multiarquitectura
Para empezar, una imagen normal tiene un manifiesto que apunta a una configuración y a unas capas. En cambio, una imagen multiarquitectura tiene una lista de manifiestos (en el formato de OCI se llama índice de imagen), que apunta a un manifiesto por plataforma. Cuando alguien descarga la imagen, el registro entrega la lista y Docker elige solo la variante de su arquitectura. Por eso el mismo docker pull nginx:1.30-alpine funciona igual en un portátil AMD64 que en una Raspberry Pi.
Para verlo, revisamos el manifiesto de cinco imágenes oficiales de Docker Hub con docker buildx imagetools inspect. Esto fue lo que publicaban el 19 de noviembre de 2026:
| Imagen | Plataformas publicadas |
|---|---|
nginx:1.30-alpine | 8: amd64, arm/v6, arm/v7, arm64/v8, 386, ppc64le, riscv64 y s390x |
alpine:3.22 | 8: las mismas que nginx |
golang:1.25-alpine | 8: las mismas que nginx |
python:3.14-slim | 8: amd64, arm/v5, arm/v7, arm64/v8, 386, ppc64le, riscv64 y s390x |
mysql:5.7 | 1: solo amd64 |
mcr.microsoft.com/mssql/server:2022-latest | 1, y sin lista de manifiestos: solo amd64 |
Además, junto a cada plataforma aparecía una entrada con la plataforma unknown/unknown. No es una arquitectura rara: son las atestaciones de la imagen, de las que hablamos más abajo.
docker manifest inspect y docker buildx imagetools inspect
En la práctica, hay dos órdenes para leer un manifiesto sin descargar la imagen. Por un lado, docker manifest inspect devuelve el JSON tal como está en el registro. Por otro, docker buildx imagetools inspect lo presenta legible, con una línea Platform: por variante, y admite --raw para ver el JSON original:
docker manifest inspect nginx:1.30-alpine
docker buildx imagetools inspect nginx:1.30-alpine
docker buildx imagetools inspect --raw nginx:1.30-alpine
Además, la línea MediaType dice qué tipo de imagen es. Si muestra application/vnd.oci.image.index.v1+json (o el antiguo application/vnd.docker.distribution.manifest.list.v2+json), es una imagen multiarquitectura. En cambio, si muestra application/vnd.oci.image.manifest.v1+json sin más entradas, la imagen es de una sola plataforma. Así era la de SQL Server 2022 en el laboratorio.
Las tres estrategias de docker buildx para varias arquitecturas
En concreto, la documentación de Docker describe tres formas de construir para varias plataformas. Además, se pueden combinar, y elegir bien entre ellas es lo que más tiempo ahorra.
Emulación con QEMU
En primer lugar, QEMU es un emulador: traduce las instrucciones de ARM64 a instrucciones de AMD64 mientras se ejecutan. Docker Desktop lo trae listo de fábrica, y en Linux las versiones oficiales de BuildKit incluyen sus propios emuladores. Si un equipo Linux no los tiene, la documentación indica registrarlos con la imagen tonistiigi/binfmt, que exige un contenedor con privilegios:
docker run --privileged --rm tonistiigi/binfmt --install all
Así pues, la gran ventaja de QEMU es que no hay que cambiar nada en el Dockerfile. Para comprobar que funciona, basta con ejecutar el mismo contenedor pidiendo otra plataforma:
docker run --rm --platform linux/amd64 alpine:3.22 uname -m
docker run --rm --platform linux/arm64 alpine:3.22 uname -m
docker run --rm --platform linux/arm/v7 alpine:3.22 uname -m
En el laboratorio respondieron x86_64, aarch64 y armv7l: el portátil AMD64 ejecutó contenedores de ARM sin ningún equipo ARM. Ahora bien, el precio es la velocidad. Un cálculo de 300.000 resúmenes SHA-256 en Python tardó 0,36 s de mediana en AMD64 y 3,46 s en ARM64 emulado, unas 9,6 veces más. Por eso, la documentación de Docker advierte que la emulación puede ser mucho más lenta en tareas de cálculo intenso, como compilar o comprimir.
Compilación cruzada
En segundo lugar, cuando el lenguaje lo admite, el compilador puede producir en AMD64 un binario para ARM64. Go, Rust, C y C++ con el compilador adecuado, .NET y Java (que genera bytecode independiente del procesador) lo hacen bien. Por lo tanto, la clave en Docker es fijar la etapa de compilación a la plataforma del builder con FROM --platform=$BUILDPLATFORM y pasarle al compilador la plataforma de destino:
FROM --platform=$BUILDPLATFORM golang:1.25-alpine AS build
ARG TARGETOS TARGETARCH
WORKDIR /src
COPY go.mod main.go ./
RUN GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /out/hola .
FROM alpine:3.22
COPY --from=build /out/hola /usr/local/bin/hola
CMD ["hola"]
Así, la etapa build corre siempre en AMD64, sin emulación, y solo la imagen final se arma con la base de cada arquitectura. En la salida de la construcción se ve con claridad: BuildKit rotula ese paso como [linux/amd64->arm64 build 4/4].
Nodos nativos
Por último, la tercera forma es que un equipo ARM64 real construya la parte de ARM64. Para ello, se añade su contexto de Docker al builder con --append:
docker buildx create --use --name multinodo nodo-amd64
docker buildx create --append --name multinodo nodo-arm64
docker buildx build --platform linux/amd64,linux/arm64 .
Sin duda, es la opción más rápida y la que mejor resuelve los casos que QEMU no puede, pero exige tener y mantener ese equipo. Como alternativa, Docker ofrece constructores administrados con nodos de las dos arquitecturas (Docker Build Cloud), y en GitHub Actions el flujo reutilizable Docker GitHub Builder reparte cada plataforma en un ejecutor nativo de GitHub, ARM incluido. En este laboratorio no tuvimos un equipo ARM64, así que esta estrategia no se midió.
Tiempos medidos: emulado frente a nativo
Por eso, para medir la diferencia, construimos dos aplicaciones pequeñas tres veces cada una, sin caché y con las imágenes base ya descargadas. La primera es un programa en Go que solo imprime su arquitectura; la segunda, una aplicación en Python que instala Flask y Gunicorn con pip.
| Construcción | Mediana | Frente a la nativa |
|---|---|---|
| Go, AMD64 nativo | 9,8 s | Referencia |
| Go, ARM64 emulado | 93,7 s | 9,6 veces más |
| Go, ARM64 con compilación cruzada | 8,8 s | Igual que la nativa |
| Go, AMD64 y ARM64 a la vez, emulado | 91,1 s | El tiempo lo marca ARM64 |
| Go, AMD64 y ARM64 a la vez, compilación cruzada | 9,9 s | Las dos por el precio de una |
| Python, AMD64 nativo | 10,5 s | Referencia |
| Python, ARM64 emulado | 49,1 s | 4,7 veces más |
De esta tabla salen dos conclusiones prácticas. Primero, al construir varias plataformas a la vez el tiempo total lo marca la más lenta, porque BuildKit las construye en paralelo. Segundo, Python se resiente menos que Go porque pip sobre todo descarga paquetes ya compilados; si un paquete tuviera que compilarse desde el código fuente, la emulación volvería a pesar mucho más.
Paso a paso: docker build arm64 y AMD64 en una sola orden de docker buildx
Así, con el Dockerfile de compilación cruzada de arriba en una carpeta, junto al main.go y al go.mod del programa, la construcción de las dos plataformas es una sola orden de docker buildx. Este es el orden de trabajo que usamos en el laboratorio:
- Construir las dos plataformas y cargarlas en el equipo:
docker buildx build --platform linux/amd64,linux/arm64 -t hola:1.0 --load . - Revisar que la imagen tiene las dos variantes:
docker image ls --tree hola - Probar cada variante:
docker run --rm --platform linux/arm64 hola:1.0 - Publicarla en el registro con su nombre definitivo:
docker buildx build --platform linux/amd64,linux/arm64 -t registro.empresa.com/hola:1.0 --push . - Comprobar en el registro el manifiesto que quedó:
docker buildx imagetools inspect registro.empresa.com/hola:1.0
En el laboratorio, el paso 2 mostró la imagen con sus dos variantes debajo:
IMAGE ID DISK USAGE CONTENT SIZE EXTRA
kh-hola:1.0 9c476c284a87 21.8MB 10.6MB
├─ linux/amd64 237a3e5ac13b 16.4MB 5.16MB
└─ linux/arm64 3cb26a3761c8 5.41MB 5.41MB
Después, el paso 3 respondió hola desde linux/arm64 y, sin --platform, hola desde linux/amd64: Docker eligió solo la variante del equipo. Por otra parte, para publicar usamos un registro de pruebas en el propio portátil (registry:3, solo en 127.0.0.1), y el paso 5 confirmó la lista con las dos plataformas.
Las variables automáticas de docker buildx
Además, durante una construcción para varias plataformas, BuildKit define unas variables (argumentos de construcción) que dicen dónde se construye y para qué. Para usarlas dentro de una etapa hay que declararlas con ARG. Este Dockerfile de prueba las imprime:
FROM alpine:3.22
ARG BUILDPLATFORM TARGETPLATFORM TARGETOS TARGETARCH TARGETVARIANT
RUN echo "construye en $BUILDPLATFORM para $TARGETPLATFORM ($TARGETOS/$TARGETARCH$TARGETVARIANT), uname -m: $(uname -m)" > /info.txt
CMD ["cat", "/info.txt"]
Así, al construirlo para tres plataformas, cada variante guardó lo siguiente:
| Variable | linux/amd64 | linux/arm64 | linux/arm/v7 |
|---|---|---|---|
BUILDPLATFORM | linux/amd64 | linux/amd64 | linux/amd64 |
TARGETPLATFORM | linux/amd64 | linux/arm64 | linux/arm/v7 |
TARGETOS | linux | linux | linux |
TARGETARCH | amd64 | arm64 | arm |
TARGETVARIANT | (vacía) | (vacía) | v7 |
uname -m dentro del paso | x86_64 | aarch64 | armv7l |
La última fila es la importante: como esa etapa no fija --platform=$BUILDPLATFORM, el paso RUN de ARM se ejecutó emulado. En cambio, BUILDPLATFORM siempre dice la arquitectura del equipo que construye, que es la que hay que pasar a FROM para compilar sin emulación.
Dónde queda el resultado: –load, –push y –output
Por otro lado, una construcción de docker buildx no deja la imagen siempre en el mismo sitio. Depende del driver y de la opción de salida:
| Opción | Qué hace | Detalle medido o documentado |
|---|---|---|
Ninguna, con el driver docker | Carga la imagen en Docker | Lo habitual en Docker Desktop |
--load | Carga la imagen en Docker | Equivale a --output type=docker; varias plataformas exigen el almacén de containerd |
--push | Publica la imagen en el registro | La forma normal de entregar una imagen multiarquitectura |
--output type=local,dest=./salida | Copia los archivos resultantes a una carpeta | Útil para extraer binarios sin crear imagen |
Ninguna, con el driver docker-container | Nada fuera de la caché | Lo avisa con un mensaje |
Sin embargo, el último caso es fácil de pasar por alto. Con un builder docker-container, la construcción terminó bien, pero buildx avisó: WARNING: No output specified with docker-container driver. Build result will only remain in the build cache. To push result image into registry use --push or to load image into docker use --load. Es decir, si nadie lee el aviso, la imagen no está en ninguna parte. Con --load, en cambio, ese mismo builder envió la imagen a Docker como archivo (sending tarball) y la dejó disponible.
Crear un builder docker-container
Asimismo, para crear un builder independiente del motor de Docker, por ejemplo para usar opciones de caché que el driver docker no admite, se usa:
docker buildx create --name multi --driver docker-container --bootstrap
docker buildx ls
docker buildx build --builder multi --platform linux/amd64,linux/arm64 -t hola:2.0 --load .
docker buildx rm multi
En el laboratorio, el arranque descargó la imagen moby/buildkit:buildx-stable-1 y tardó 17,4 s; ese builder trajo BuildKit 0.34.2, algo más nuevo que el que lleva dentro Docker Desktop (0.34.0). Finalmente, al terminar conviene borrarlo con docker buildx rm, porque es un contenedor más que consume recursos.
Las entradas unknown/unknown: atestaciones
Por otra parte, al revisar la imagen que publicamos en el registro de pruebas apareció algo que desconcierta la primera vez: la lista tenía cuatro entradas, no dos. Además de linux/amd64 y linux/arm64 había dos con plataforma unknown/unknown y la anotación vnd.docker.reference.type: attestation-manifest. Son atestaciones: un registro en formato in-toto de cómo se construyó cada variante.
Según la documentación de Docker, BuildKit añade de fábrica una atestación de procedencia (provenance) en modo min, con datos como las marcas de tiempo y el frontend usado. No contiene el Dockerfile; el modo max, que sí lo incluye codificado, hay que pedirlo con --provenance=mode=max. Si un registro antiguo o una herramienta no entiende esas entradas, se desactivan así:
docker buildx build --platform linux/amd64,linux/arm64 --provenance=false --sbom=false -t registro.empresa.com/hola:1.0 --push .
De hecho, con esa orden, la lista del registro de pruebas quedó con solo las dos plataformas. Ahora bien, antes de quitarlas conviene saber que sirven para auditar de dónde sale una imagen; si el registro las admite, lo razonable es dejarlas.
Imágenes que solo existen para una arquitectura
Por desgracia, no todas las imágenes publican ARM64. En el laboratorio probamos dos casos reales y se comportaron de forma muy distinta, lo que conviene conocer antes de migrar un servicio a ARM.
Por un lado, el primero, mysql:5.7, tiene lista de manifiestos con una sola plataforma. Al pedirla para ARM64, Docker la rechazó en el acto: no matching manifest for linux/arm64 in the manifest list entries. Es el caso fácil, porque el error aparece antes de descargar nada.
Por otro lado, el segundo, mcr.microsoft.com/mssql/server:2022-latest, no tiene lista: es un único manifiesto de AMD64. Al pedirlo con docker pull --platform linux/arm64, Docker descargó los 2,2 GB de la imagen de AMD64 sin ningún error ni aviso. En cambio, el fallo llegó después, al ejecutarla: image with reference mcr.microsoft.com/mssql/server:2022-latest was found but does not provide the specified platform (linux/arm64). En un equipo ARM64 sin emulación, el síntoma sería el exec format error.
Por eso, la comprobación fiable se hace antes de descargar, leyendo el manifiesto:
docker buildx imagetools inspect mcr.microsoft.com/mssql/server:2022-latest
docker buildx imagetools inspect --raw mysql:5.7
Por último, si la imagen que se necesita no existe para ARM64, quedan tres caminos: buscar una alternativa que sí la publique (por ejemplo, una versión más reciente), construirla uno mismo desde su código fuente con docker buildx o ejecutarla emulada con --platform linux/amd64, aceptando que irá varias veces más lenta.
exec format error: qué significa y cómo resolverlo
En general, el exec format error es el síntoma típico de una arquitectura equivocada: el núcleo recibe un binario que no sabe ejecutar. Suele aparecer al arrancar el contenedor, como exec /usr/local/bin/hola: exec format error, y tiene tres causas habituales:
- La imagen se construyó para otra arquitectura: por ejemplo, en un Mac con Apple Silicon (ARM64) y se desplegó en un servidor AMD64. Se resuelve construyendo la imagen multiarquitectura con
--platform linux/amd64,linux/arm64. - Un binario copiado dentro de la imagen no corresponde a la plataforma: un
COPYo una descarga concurlque trae siempre el binario de AMD64. Se resuelve eligiendo el archivo segúnTARGETARCH. - Un script sin intérprete: un
entrypoint.shal que le falta la primera línea#!/bin/shda el mismo mensaje, aunque la arquitectura sea la correcta. Se resuelve añadiendo esa línea.
En Docker Desktop no reprodujimos el error, porque su emulación QEMU ejecuta cualquier binario ARM de forma transparente; precisamente por eso, una imagen equivocada puede funcionar en el portátil y fallar en el servidor. Por eso, para saber de qué arquitectura es una imagen local, sirve docker image inspect hola:1.0 --format "{{.Os}}/{{.Architecture}}".
Órdenes de docker buildx para consultar y mantener
A modo de resumen, esta tabla reúne las órdenes que más se usan en el día a día, todas comprobadas en el laboratorio salvo donde se indica:
| Orden | Para qué sirve |
|---|---|
docker buildx ls | Lista los builders y sus plataformas |
docker buildx inspect --bootstrap | Arranca el builder y muestra su BuildKit y sus plataformas |
docker buildx build --platform linux/amd64,linux/arm64 -t imagen:1.0 --push . | Construye y publica la imagen multiarquitectura |
docker buildx imagetools inspect imagen:1.0 | Muestra la lista de manifiestos del registro |
docker manifest inspect imagen:1.0 | Lo mismo, en JSON crudo |
docker buildx imagetools create -t imagen:estable imagen:1.0 | Crea otra etiqueta en el registro sin descargar nada (0,3 s en el laboratorio) |
docker image ls --tree | Muestra las variantes de cada imagen local |
docker buildx du | Muestra lo que ocupa la caché de construcción |
docker buildx prune | Borra la caché de construcción que no se usa |
docker buildx bake | Construye varios objetivos definidos en un archivo (no probado aquí) |
Además, la caché merece atención en los equipos de desarrollo: en el portátil del laboratorio, docker buildx du informó de 34,48 GB recuperables. Por lo tanto, un docker buildx prune de vez en cuando libera mucho disco.
Errores frecuentes con docker buildx
| Mensaje | Causa | Solución |
|---|---|---|
no matching manifest for linux/arm64 in the manifest list entries | La imagen no publica esa arquitectura | Buscar otra imagen o construirla |
was found but does not provide the specified platform | Se descargó la variante de otra arquitectura | Revisar el manifiesto con imagetools inspect |
exec format error | Binario de otra arquitectura o script mal formado | Ver el apartado anterior |
No output specified with docker-container driver | Sin --load ni --push | Añadir la salida que corresponda |
Attestation is not supported for the docker driver (documentado) | Motor con el almacén de imágenes clásico | Activar el de containerd o usar --provenance=false --sbom=false |
| Compilación lentísima para ARM64 | Paso pesado ejecutado con QEMU | Compilación cruzada con FROM --platform=$BUILDPLATFORM |
Docker buildx en la empresa
En definitiva, para un área de TI, la imagen multiarquitectura resuelve un problema concreto: el mismo nombre de imagen sirve en los portátiles de desarrollo, en los servidores de la oficina y en la nube, sea cual sea el procesador. Por eso, antes de adoptarla, conviene revisar tres cosas: qué imágenes base usa cada servicio y si publican ARM64; si la compilación cruzada es posible en el lenguaje de cada aplicación, y dónde se va a construir, porque una compilación emulada puede alargar mucho la entrega.
Si su empresa está empezando con contenedores, las guías de Docker, Docker Compose y Docker Swarm explican la base sobre la que se apoya todo esto, y la de Ubuntu vs Debian ayuda a elegir el sistema del servidor que los ejecuta. Para la documentación completa, Docker mantiene sus guías de construcción multiplataforma, la referencia de la orden build y la explicación de las atestaciones.
Cómo lo aborda KHARONTE
En KHARONTE administramos la infraestructura sobre la que corren los contenedores: servidores, virtualización, almacenamiento y redes, dentro de nuestra línea de infraestructura TI. Por ejemplo, ayudamos a preparar los servidores que ejecutan Docker, a mantener el sistema operativo y el motor al día y a integrarlos con las copias de seguridad y el monitoreo. Eso sí, la programación de las aplicaciones y la construcción de sus imágenes siguen siendo del equipo que las programa.
Además, esa administración forma parte de nuestros servicios administrados de TI, con la misma mesa de ayuda TI que atiende los casos de los usuarios. Si prefiere delegar la operación completa, el outsourcing de infraestructura de TI cubre el día a día de los servidores, y en nuestra página de servicios de TI para empresas está el portafolio completo.




