Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Création d'images de conteneurs simples AL2023
<a name="barebones-containers"></a>

L'image du conteneur AL2023 est créée à partir des mêmes composants logiciels que ceux inclus dans l'AMI AL2023. Il inclut un logiciel qui permet à la couche conteneur de base de se comporter de la même manière qu'une exécution sur une instance Amazon EC2, tel que le gestionnaire de packages. `dnf` Cette section explique comment créer un conteneur à partir de zéro qui inclut uniquement le strict minimum de dépendances nécessaires à une application.

**Note**  
Les images de AL2023 conteneur standard conviennent à la plupart des cas d'utilisation. L'utilisation de l'image de conteneur standard facilite la création par-dessus votre image. Une image de conteneur simplifiée complique la création à partir de votre image.

**Pour créer un conteneur avec le strict minimum de dépendances pour une application**

1. Déterminez les dépendances de votre environnement d'exécution. Elles varient en fonction de votre application.

1. Construisez un `Dockerfile` / `Containerfile` qui génère `FROM scratch`. L'exemple suivant de `Dockerfile` peut être utilisé pour générer un conteneur contenant uniquement le shell `bash` et ses dépendances.

   ```
   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. Ce `Dockerfile` fonctionne comme suit :

     1.  Démarrer un AL2023 conteneur nommé`build`. Ce conteneur sera utilisé pour amorcer le conteneur élémentaire. Il n'est pas déployé lui-même, mais génère le conteneur à déployer. 

     1.  Il crée le répertoire `/sysroot`. Ce répertoire sera l'emplacement où le conteneur `build` installera les dépendances nécessaires au conteneur élémentaire. Dans une étape ultérieure, le chemin `/sysroot` sera empaqueté comme répertoire racine de notre image élémentaire. 

         C'est `dnf` en utilisant l'`--installroot`option de cette manière que nous créons les autres AL2023 images. Il s'agit d'une fonctionnalité de `dnf` qui permet aux programmes d'installation et aux outils de création d'images de fonctionner. 

     1.  Il invoque `dnf` pour installer des packages dans `/sysroot`. 

         La commande `rpm -q system-release --qf '%{VERSION}'` interroge (`-q`) le package `system-release`, en définissant le format de requête (`--qf`) pour fournir en sortie la version du package interrogé (la variable `%{VERSION}` est la variable `rpm` correspondant à la version du `RPM`). 

         En définissant l'argument `--releasever` de `dnf` sur la version de `system-release` dans le conteneur `build`, ce `Dockerfile` peut être utilisé pour reconstruire le conteneur élémentaire chaque fois qu'une image de base de conteneur mise à jour d'Amazon Linux est publiée. 

         Il est possible de définir n'importe quelle version `--releasever` d'Amazon Linux 2023, telle que 2023.10.20260325. Cela signifierait que le `build` conteneur fonctionnerait en tant que dernière AL2023 version, mais que le conteneur barebones serait créé à partir du 2023.10.20260325, quelle que soit la version actuelle. AL2023 

         L'option de configuration `--setopt=install_weak_deps=False` indique à `dnf` d'installer uniquement les dépendances *requises* plutôt que celles recommandées ou suggérées. 

     1. Il copie le système installé à la racine d'un conteneur vierge (`FROM scratch`).

     1. Il définit `ENTRYPOINT` comme binaire souhaité, dans ce cas `/bin/bash`.

1. Créez un répertoire vide et ajoutez le contenu de l'exemple à l'étape 2 dans un fichier nommé `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. Générez le conteneur en exécutant la commande suivante.

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

1. Exécutez le conteneur à l'aide de la commande suivante pour voir à quel point un conteneur dédié à `bash` est minimal.

   ```
   $ 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
   ```

Pour un exemple plus pratique, la procédure suivante crée un conteneur pour une application C qui affiche `Hello World!`.

1. Créez un répertoire vide et ajoutez le code source C et `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. Générez le conteneur à l'aide de la commande suivante.

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

1. Exécutez le conteneur à l'aide de la commande suivante.

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