# Creando una imagen de contenedor con soporte multiarquitectura

Por lo general, cuando se crea una imagen de contenedor, esta se construye con el objetivo de correrla en la misma plataforma de hardware en la cual es construído, sin embargo, es posible utilizar un emulador como QEMU para crear una imagen que pueda correr en otros dispositivos con una arquitectura distinta. Un ejemplo de esto sería correr un un mismo contenedor en un computador con soporte para instrucciones x86 (Intel/AMD) o en un Raspberry Pi (Arm).

# Pre-requisitos

Para nuestro laboratorio, vamos a utilizar una computadora x86 corriendo Ubuntu. Adicionalmente, es necesario tener Docker instalado [utilizando las instrucciones oficiales](https://docs.docker.com/engine/install/ubuntu/).

Adicionalmente, es necesario contar con una cuenta en Docker hub (gratis)

# Procedimiento

* Instalar QEMU en el sistema operativo
    
    ```bash
    apt install -y qemu-user-static
    ```
    
* Correr Binfmt en un contenedor
    
    ```bash
    docker run --privileged --rm tonistiigi/binfmt --install all
    ```
    
* Configurar Buildkit
    
    ```bash
    docker buildx create --use --name mymultiarchbuilder \
      --driver docker-container
    
    docker buildx inspect --bootstrap
    ```
    
* Iniciar sesión en Docker Hub
    
    ```bash
    docker login
    ```
    
* Crear el contenedor. Por favor note que **es necesario** reemplazar “<my username>” en el script con su username del Docker Hub
    
    ```bash
    docker buildx build \
            -t <my username>/mymultiarch:latest \
            --platform linux/386,linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64/v8,linux/ppc64le,linux/riscv64,linux/s390x,linux/arm64 \
            --push \
            -f - . <<EOF
                    FROM alpine:latest
                    # Install bash inside the image for all target platforms
                    RUN apk add bash
    
                    # Define the command that will run when the container starts
                    CMD ["sh", "-c", "echo 'Hola desde Arch: $(uname -m)' && /bin/bash"]
    EOF
    ```
    
* Inspeccionando la imagen
    
    ```bash
    docker buildx imagetools inspect <my username>/mymultiarch:latest
    ```
    

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1761248796920/94261e66-239f-400f-abed-36c4fc93e0db.png align="center")

# Pruebas

* Corra el contenedor en diferentes hardware en diferentes plataformas
    
    ```bash
    docker run --rm <my username>/mymultiarch:latest uname -m
    ```
    

Dependiendo de la plataforma desde la que ejecute el comando se mostrará la arquitectura en la que está corriendo el contenedor

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1761254942521/ffe39eeb-6ec1-4ad6-80f9-e1f48be79b51.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1761254898995/5e8e5acd-fd3e-4f76-91cf-76eb76779512.png align="center")

Adicionalmente, puede abrir la imagen en Docker Hub y ver todas las plataformas que son soportadas por el contenedor

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1761248295728/df0253d5-8523-4c36-a059-0d402696222c.png align="center")

# Conclusión

Es posible lograr que su software corra en varias plataformas logrando un rendimiento nativo gracias a la tecnología de cross compiling que permite lograr una verdadera multiarquitectura en donde su software no corre siendo emulado sino utilizando las instrucciones nativas que ofrece el procesador. De la misma manera, este tipo de contenedores pueden ser utilizados en clusters de Kubernetes que ofrecen capacidades de hospedaje híbrido, en donde usted podría por ejemplo correr su software en hardware x86 a la par de estaciones de trabajo Apple con procesadores de la serie M (arm64) de una forma completamente transparente.