# Migrar desde Ubuntu Las Docker Hardened Images (DHI) están disponibles tanto en [variantes basadas en Alpine como en Debian](/dhi/explore/available/). Al migrar desde una imagen basada en Ubuntu, debes migrar a la variante DHI basada en Debian, ya que tanto Ubuntu como Debian comparten el mismo sistema de gestión de paquetes (APT) y la misma arquitectura subyacente, lo que hace que la migración sea directa. Esta guía te ayuda a migrar de una imagen existente basada en Ubuntu a DHI. ## Diferencias clave Al migrar de imágenes basadas en Ubuntu a DHI Debian, ten en cuenta estas diferencias clave: | Elemento | Imágenes basadas en Ubuntu | Docker Hardened Images | |:-------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Gestión de paquetes | Varía según la imagen. Algunas incluyen el gestor de paquetes APT, otras no. | Por lo general, los gestores de paquetes solo están disponibles en las imágenes con la etiqueta `dev`. Las imágenes de ejecución no contienen gestores de paquetes. Usa compilaciones multi-stage y copia los artefactos necesarios de la etapa de compilación a la etapa de ejecución. | | Usuario no root | Varía según la imagen. Algunas se ejecutan como root, otras como no root. | Las variantes de tiempo de ejecución se ejecutan como el usuario no root por defecto. Asegúrate de que el usuario no root tenga acceso a los archivos y directorios necesarios. | | Compilación multi-stage | Recomendado | Recomendado. Usa imágenes con etiquetas `dev` o `sdk` para las etapas de compilación e imágenes que no sean dev para la ejecución. | | Puertos | Pueden enlazarse a puertos privilegiados (inferiores a 1024) al ejecutarse como root. | Se ejecutan como usuario no root por defecto. Las aplicaciones no pueden enlazarse a puertos privilegiados (inferiores a 1024) cuando se ejecutan en Kubernetes o en versiones de Docker Engine anteriores a la 20.10. Configura tu aplicación para que escuche en el puerto 1025 o superior dentro del contenedor. | | Punto de entrada | Varía según la imagen. | Pueden tener puntos de entrada diferentes a los de las imágenes basadas en Ubuntu. Inspecciona los puntos de entrada y actualiza tu Dockerfile si es necesario. | | Shell | Varía según la imagen. Algunas incluyen shell, otras no. | Las imágenes de ejecución no contienen una shell. Usa imágenes `dev` en las etapas de compilación para ejecutar comandos de shell y luego copia los artefactos a la etapa de ejecución. | | Repositorios de paquetes | Utiliza repositorios de paquetes de Ubuntu. | Utiliza repositorios de paquetes de Debian. La mayoría de los paquetes tienen nombres similares, pero algunos pueden diferir. | ## Pasos de migración ### Paso 1: Actualizar la imagen base en tu Dockerfile Actualiza la imagen base en el Dockerfile de tu aplicación a una imagen securizada. Normalmente será una imagen etiquetada como `dev` o `sdk` porque tiene las herramientas necesarias para instalar paquetes y dependencias. El siguiente fragmento de diff de un Dockerfile muestra la antigua imagen basada en Ubuntu reemplazada por la nueva imagen DHI Debian. > [!NOTE] > > Debes autenticarte en `dhi.io` antes de poder descargar Docker Hardened Images. Usa tus credenciales de Docker ID (el mismo usuario y contraseña que usas para Docker Hub). Si no tienes una cuenta de Docker, [crea una](/accounts/create-account/) de forma gratuita. > > Ejecuta `docker login dhi.io` para autenticarte. ```diff - ## Original Ubuntu-based image - FROM ubuntu/go:1.22-24.04 + ## Updated to use hardened Debian-based image + FROM dhi.io/golang:1-debian13-dev ``` Para encontrar la etiqueta correcta, explora las etiquetas disponibles en el [Catálogo de DHI](https://hub.docker.com/hardened-images/catalog/). ### Paso 2: Actualizar los comandos de instalación de paquetes Dado que tanto Ubuntu como Debian utilizan APT para la gestión de paquetes, la mayoría de los comandos de instalación de paquetes siguen siendo similares. Sin embargo, debes asegurarte de que las instalaciones de paquetes solo ocurran en las imágenes `dev` o `sdk`, ya que las imágenes de ejecución no contienen gestores de paquetes. ```diff - ## Ubuntu: Installing packages - FROM ubuntu/go:1.22-24.04 - RUN apt-get update && apt-get install -y \ - git \ - && rm -rf /var/lib/apt/lists/* + ## DHI: Use a language-specific dev image with package manager + FROM dhi.io/golang:1-debian13-dev + RUN apt-get update && apt-get install -y \ + git \ + && rm -rf /var/lib/apt/lists/* ``` La mayoría de los paquetes de Ubuntu están disponibles en Debian con los mismos nombres. Si no encuentras algún paquete, puedes buscar paquetes equivalentes en el sitio web de [búsqueda de paquetes de Debian](https://packages.debian.org/). ### Paso 3: Actualizar la imagen de ejecución en tu Dockerfile > [!NOTE] > > Se recomiendan las compilaciones multi-stage para mantener la imagen final mínima y segura. Las compilaciones de una sola etapa son compatibles, pero incluyen la imagen `dev` completa y, por lo tanto, dan como resultado una imagen más grande con una superficie de ataque más amplia. Para garantizar que tu imagen final sea lo más mínima posible, debes utilizar una [compilación multi-stage](/build/building/multi-stage/). Todas las etapas de tu Dockerfile deben utilizar una imagen securizada. Mientras que las etapas intermedias normalmente utilizarán imágenes etiquetadas como `dev` o `sdk`, tu etapa final de ejecución debe utilizar una imagen de ejecución. Utiliza la etapa de compilación para instalar dependencias y preparar tu aplicación, y luego copia los artefactos resultantes a la etapa final de ejecución. Esto garantiza que tu imagen final sea mínima y segura. El siguiente ejemplo muestra un Dockerfile multi-stage de migración de Ubuntu a DHI Debian: ```dockerfile # Build stage FROM dhi.io/golang:1-debian13-dev AS builder WORKDIR /app # Instalar dependencias del sistema (solo disponibles en imágenes dev) RUN apt-get update && apt-get install -y \ git \ && rm -rf /var/lib/apt/lists/* # Copiar archivos de la aplicación COPY go.mod go.sum ./ RUN go mod download COPY . . RUN CGO_ENABLED=0 GOOS=linux go build -a -ldflags="-s -w" -o main . # Runtime stage FROM dhi.io/golang:1-debian13 WORKDIR /app # Copiar el binario compilado desde el builder COPY --from=builder /app/main /app/main # Ejecutar la aplicación ENTRYPOINT ["/app/main"] ``` ## Ejemplos específicos de lenguajes Consulta la sección de ejemplos para ver ejemplos de migración específicos de cada lenguaje: - [Go](/dhi/migration/migrate-from-ubuntu/examples/go/) - [Python](/dhi/migration/migrate-from-ubuntu/examples/python/) - [Node.js](/dhi/migration/migrate-from-ubuntu/examples/node/)