Docker buildx: una misma imagen de Docker para AMD64 y ARM64

Docker buildx: terminal portuaria de contenedores de noche, con grúas, pilas de contenedores de colores y calles iluminadas entre ellas

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é).

EstrategiaQué haceTiempo medido para ARM64Cuándo usarla
Nativa (referencia)Compila para la misma arquitectura del equipo9,8 s (AMD64)Siempre que se pueda
Emulación con QEMUEjecuta los pasos de ARM64 traduciendo cada instrucción93,7 sImágenes sencillas, sin compilación pesada
Compilación cruzadaCompila en AMD64 un binario para ARM648,8 sGo, Rust, .NET, Java y otros lenguajes que la admiten
Nodos nativosUn equipo ARM64 real construye su parteNo 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:

DriverDónde corre BuildKitCarga la imagen en Docker solaImágenes multiarquitectura
dockerDentro del propio motor de DockerSíSí, con el almacén de imágenes de containerd
docker-containerEn un contenedor aparteNo: hace falta --load o --pushSí
kubernetesEn pods de un clúster de KubernetesNoSí
remoteEn un BuildKit que se administra a manoNoSí
cloudEn los constructores de Docker Build CloudSegún el casoSí

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:

ImagenPlataformas publicadas
nginx:1.30-alpine8: amd64, arm/v6, arm/v7, arm64/v8, 386, ppc64le, riscv64 y s390x
alpine:3.228: las mismas que nginx
golang:1.25-alpine8: las mismas que nginx
python:3.14-slim8: amd64, arm/v5, arm/v7, arm64/v8, 386, ppc64le, riscv64 y s390x
mysql:5.71: solo amd64
mcr.microsoft.com/mssql/server:2022-latest1, 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ónMedianaFrente a la nativa
Go, AMD64 nativo9,8 sReferencia
Go, ARM64 emulado93,7 s9,6 veces más
Go, ARM64 con compilación cruzada8,8 sIgual que la nativa
Go, AMD64 y ARM64 a la vez, emulado91,1 sEl tiempo lo marca ARM64
Go, AMD64 y ARM64 a la vez, compilación cruzada9,9 sLas dos por el precio de una
Python, AMD64 nativo10,5 sReferencia
Python, ARM64 emulado49,1 s4,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:

  1. Construir las dos plataformas y cargarlas en el equipo: docker buildx build --platform linux/amd64,linux/arm64 -t hola:1.0 --load .
  2. Revisar que la imagen tiene las dos variantes: docker image ls --tree hola
  3. Probar cada variante: docker run --rm --platform linux/arm64 hola:1.0
  4. Publicarla en el registro con su nombre definitivo: docker buildx build --platform linux/amd64,linux/arm64 -t registro.empresa.com/hola:1.0 --push .
  5. 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:

Variablelinux/amd64linux/arm64linux/arm/v7
BUILDPLATFORMlinux/amd64linux/amd64linux/amd64
TARGETPLATFORMlinux/amd64linux/arm64linux/arm/v7
TARGETOSlinuxlinuxlinux
TARGETARCHamd64arm64arm
TARGETVARIANT(vacía)(vacía)v7
uname -m dentro del pasox86_64aarch64armv7l

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ónQué haceDetalle medido o documentado
Ninguna, con el driver dockerCarga la imagen en DockerLo habitual en Docker Desktop
--loadCarga la imagen en DockerEquivale a --output type=docker; varias plataformas exigen el almacén de containerd
--pushPublica la imagen en el registroLa forma normal de entregar una imagen multiarquitectura
--output type=local,dest=./salidaCopia los archivos resultantes a una carpetaÚtil para extraer binarios sin crear imagen
Ninguna, con el driver docker-containerNada 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:

  1. 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.
  2. Un binario copiado dentro de la imagen no corresponde a la plataforma: un COPY o una descarga con curl que trae siempre el binario de AMD64. Se resuelve eligiendo el archivo según TARGETARCH.
  3. Un script sin intérprete: un entrypoint.sh al que le falta la primera línea #!/bin/sh da 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:

OrdenPara qué sirve
docker buildx lsLista los builders y sus plataformas
docker buildx inspect --bootstrapArranca 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.0Muestra la lista de manifiestos del registro
docker manifest inspect imagen:1.0Lo mismo, en JSON crudo
docker buildx imagetools create -t imagen:estable imagen:1.0Crea otra etiqueta en el registro sin descargar nada (0,3 s en el laboratorio)
docker image ls --treeMuestra las variantes de cada imagen local
docker buildx duMuestra lo que ocupa la caché de construcción
docker buildx pruneBorra la caché de construcción que no se usa
docker buildx bakeConstruye 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

MensajeCausaSolución
no matching manifest for linux/arm64 in the manifest list entriesLa imagen no publica esa arquitecturaBuscar otra imagen o construirla
was found but does not provide the specified platformSe descargó la variante de otra arquitecturaRevisar el manifiesto con imagetools inspect
exec format errorBinario de otra arquitectura o script mal formadoVer el apartado anterior
No output specified with docker-container driverSin --load ni --pushAñadir la salida que corresponda
Attestation is not supported for the docker driver (documentado)Motor con el almacén de imágenes clásicoActivar el de containerd o usar --provenance=false --sbom=false
Compilación lentísima para ARM64Paso pesado ejecutado con QEMUCompilació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.

Hablemos de la TI de su empresa

Cuéntenos qué necesita su operación y le enviamos una propuesta por escrito. Cada línea del portafolio se contrata por separado.

Compartir este artículo

Últimas entradas

Escríbanos ahora