Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Creación de imágenes de contenedores básicas AL2023
<a name="barebones-containers"></a>

La imagen de contenedor de AL2023 se construye desde los mismos componentes de software que se incluyen en la AMI de AL2023. Incluye un software que permite que la capa base del contenedor se comporte de manera similar a como lo haría en una instancia de Amazon EC2, como el `dnf` del administrador de paquetes. En esta sección se explica cómo se puede crear un contenedor desde cero que incluya solo las dependencias mínimas necesarias para una aplicación.

**nota**  
Las imágenes de AL2023 contenedores estándar son adecuadas para la mayoría de los casos de uso. El uso de la imagen de contenedor estándar facilita la creación sobre la imagen. Una imagen de contenedor básica dificulta la creación de imágenes basadas en ella.

**Creación de un contenedor con las dependencias básicas mínimas para una aplicación**

1. Determine las dependencias del tiempo de ejecución. Esto variará en función de la aplicación.

1. Cree un `Dockerfile` / `Containerfile` que se genere `FROM scratch`. El siguiente ejemplo de un `Dockerfile` se puede utilizar para crear un contenedor que contenga solo el intérprete de comandos `bash` y sus dependencias.

   ```
   FROM public.ecr.aws/amazonlinux/amazonlinux:2023 as build
   RUN mkdir /sysroot
   RUN dnf --releasever=$(rpm -q system-release --qf '%{VERSION}') \
     --installroot /sysroot \
     -y \
     --setopt=install_weak_deps=False \
     install bash
   
   FROM scratch
   COPY --from=build /sysroot /
   WORKDIR /
   ENTRYPOINT ["/bin/bash"]
   ```

   1. Este `Dockerfile` funciona de la siguiente manera:

     1.  Iniciar un AL2023 contenedor llamado`build`. Este contenedor se utilizará para arrancar el contenedor básico. Este contenedor no se implementa por sí mismo, sino que genera el contenedor que se va a implementar. 

     1.  Creando el directorio `/sysroot`. En este directorio, el contenedor `build` instalará las dependencias necesarias para el contenedor básico. En un paso posterior, la ruta `/sysroot` se empaquetará para que sea el directorio raíz de nuestra imagen básica. 

         Usando la `--installroot` opción de esta `dnf` manera es como creamos las otras AL2023 imágenes. Es una característica de `dnf` que permite que funcionen los instaladores y las herramientas de creación de imágenes. 

     1.  Invocación a `dnf` para instalar paquetes en `/sysroot`. 

         El comando `rpm -q system-release --qf '%{VERSION}'` consulta (`-q`) el paquete `system-release` y establece el formato de consulta (`--qf`) para imprimir la versión del paquete que se está consultando (la variable `%{VERSION}` es la variable `rpm` de la versión de `RPM`). 

         Al establecer el argumento `--releasever` de `dnf` en la versión del `system-release` en el contenedor `build`, este `Dockerfile` se puede utilizar para reconstruir el contenedor básico siempre que se publique una imagen base de contenedores actualizada de Amazon Linux. 

         Es posible configurarlo en cualquier versión de `--releasever` Amazon Linux 2023, como la 2023.10.20260325. De este modo, el `build` contenedor se ejecutaría como la AL2023 versión más reciente, pero se compilaría el contenedor básico a partir de la 2023.10.20260325, independientemente de cuál fuera la versión actual. AL2023 

         La opción de configuración `--setopt=install_weak_deps=False` indica a `dnf` que solo hay que instalar las dependencias que sean *necesarias* y no las recomendadas o sugeridas. 

     1. Copia del sistema instalado en la raíz de un contenedor vacío (`FROM scratch`).

     1. Definición de `ENTRYPOINT` como el binario deseado, en este caso, `/bin/bash`.

1. Cree un directorio vacío y agregue el contenido del ejemplo del paso 2 a un archivo denominado `Dockerfile`.

   ```
   $ mkdir al2023-barebones-bash-example
   	$ cd al2023-barebones-bash-example
   	$ cat > Dockerfile <<EOF
   FROM public.ecr.aws/amazonlinux/amazonlinux:2023 as build
   RUN mkdir /sysroot
   RUN dnf --releasever=$(rpm -q system-release --qf '%{VERSION}') \
     --installroot /sysroot \
     -y \
     --setopt=install_weak_deps=False \
     install bash && dnf --installroot /sysroot clean all
   
   FROM scratch
   COPY --from=build /sysroot /
   WORKDIR /
   ENTRYPOINT ["/bin/bash"]
   EOF
   ```

1. Cree el contenedor ejecutando el siguiente comando.

   ```
   $ docker build -t al2023-barebones-bash-example
   ```

1. Ejecute el contenedor con el siguiente comando para ver qué tan mínimo es un contenedor de `bash` exclusivo.

   ```
   $ docker run -it --rm al2023-barebones-bash-example
   bash-5.2# rpm
   bash: rpm: command not found
   bash-5.2# du -sh /usr/
   bash: du: command not found
   bash-5.2# ls
   bash: ls: command not found
   bash-5.2# echo /bin/*
   /bin/alias /bin/bash /bin/bashbug /bin/bashbug-64 /bin/bg /bin/catchsegv /bin/cd /bin/command /bin/fc /bin/fg /bin/gencat /bin/getconf /bin/getent /bin/getopts /bin/hash /bin/iconv /bin/jobs /bin/ld.so /bin/ldd /bin/locale /bin/localedef /bin/pldd /bin/read /bin/sh /bin/sotruss /bin/sprof /bin/type /bin/tzselect /bin/ulimit /bin/umask /bin/unalias /bin/wait /bin/zdump
   ```

Para obtener un ejemplo más práctico, el siguiente procedimiento crea un contenedor para una aplicación en C que muestra `Hello World!`.

1. Cree un directorio vacío y agregue el código fuente C y `Dockerfile`.

   ```
   $ mkdir al2023-barebones-c-hello-world-example
   $ cd al2023-barebones-c-hello-world-example
   $ cat > hello-world.c <<EOF
   #include <stdio.h>
   int main(void)
   {
     printf("Hello World!\n");
     return 0;
   }
   EOF
   
   $ cat > Dockerfile <<EOF
   FROM public.ecr.aws/amazonlinux/amazonlinux:2023 as build
   COPY hello-world.c /
   RUN dnf -y install gcc
   RUN gcc -o hello-world hello-world.c
   RUN mkdir /sysroot
   RUN mv hello-world /sysroot/
   RUN dnf --releasever=$(rpm -q system-release --qf '%{VERSION}') \
     --installroot /sysroot \
     -y \
     --setopt=install_weak_deps=False \
     install glibc && dnf --installroot /sysroot clean all
   
   FROM scratch
   COPY --from=build /sysroot /
   WORKDIR /
   ENTRYPOINT ["/hello-world"]
   EOF
   ```

1. Cree el contenedor con el siguiente comando.

   ```
   $ docker build -t al2023-barebones-c-hello-world-example .
   ```

1. Ejecute el contenedor con el siguiente comando.

   ```
   $ docker run -it --rm al2023-barebones-c-hello-world-example
   Hello World!
   ```