Criando imagens básicas de contêineres 023 AL2

Para criar um contêiner com dependências mínimas para um aplicativo

1. Determine suas dependências de tempo de execução. Isso variará de acordo com sua inscrição.

2. Construa um Dockerfile / Containerfile que constrói FROM scratch. O exemplo a seguir de Dockerfile pode ser usado para criar um contêiner que contém somente bash shell e suas dependências.

   
   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 ao:

      1. Iniciando um contêiner AL2 023 chamadobuild. Esse contêiner será usado para inicializar o contêiner básico. Esse contêiner não é implantado sozinho, mas gera o contêiner a ser implantado.

      2. Criar o diretório /sysroot. Esse diretório será onde o contêiner build instalará as dependências necessárias para o contêiner de barebones. Em uma etapa subsequente, o /sysroot caminho será empacotado para ser o diretório raiz de nossa imagem básica.

         Usar a --installroot opção dessa dnf maneira é como criamos as outras AL2 023 imagens. Trata-se de um recurso de dnf que permite que instaladores e ferramentas de criação de imagens funcionem.

      3. Invocar dnf para instalar pacotes em /sysroot.

         O comando rpm -q system-release --qf '%{VERSION}' consulta (-q) o pacote %{VERSION}, definindo o formato da consulta (--qf) para imprimir a versão do pacote que está sendo consultado (a variável system-release é a variável rpm da versão do RPM).

         Ao definir o argumento --releasever de dnf para a versão de system-release no contêiner build, o Dockerfile pode ser usado para reconstruir o contêiner básico sempre que uma imagem base de contêiner atualizada do Amazon Linux for lançada.

         É possível definir o --releasever para qualquer versão do Amazon Linux 2023, como 2023.6.20250203. Isso significaria que o build contêiner seria executado como a versão AL2 023 mais recente, mas construiria o contêiner básico a partir de 2023.6.20250203, independentemente de qual fosse a versão 023 atual. AL2

         A opção --setopt=install_weak_deps=False de configuração diz dnf para instalar somente as dependências necessárias, em vez de recomendadas ou sugeridas.

      4. Copiar o sistema instalado na raiz de um contêiner vazio (FROM scratch).

      5. Definindo ENTRYPOINT o como o binário desejado, neste caso /bin/bash.

3. Crie um diretório vazio e adicione o conteúdo do exemplo na Etapa 2 a um arquivo chamado 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
   	

4. Crie o contêiner executando o comando a seguir.

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

5. Execute o contêiner usando o comando a seguir para ver o quão mínimo é um contêiner de somente bash.

   $ 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
   

1. Crie um diretório vazio e adicione o código-fonte C e 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
   
   

2. Execute o contêiner usando o seguinte comando.

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

3. Execute o contêiner usando o seguinte comando.

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