As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Criando imagens básicas de contêineres AL2023
<a name="barebones-containers"></a>

A imagem de contêiner do AL2023 é criada com base nos mesmos componentes de software que são incluídos na AMI do AL2023. Essa tag inclui um software que possibilita que a camada de base do contêiner se comporte de forma semelhante à execução em uma instância do Amazon EC2, como o gerenciador de pacotes `dnf`. Esta seção explica como você pode construir um contêiner do zero que inclua apenas as dependências mínimas necessárias para uma aplicação.

**nota**  
As imagens de AL2023 contêiner padrão são adequadas para a maioria dos casos de uso. O uso da imagem de contêiner padrão facilita a criação em cima da imagem. Uma imagem de contêiner básico dificulta a criação sobre a sua imagem.

**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.

1. 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 AL2023 contêiner chamado`build`. 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. 

     1.  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 de dessa `dnf` maneira é como criamos as outras AL2023 imagens. Trata-se de um recurso de `dnf` que permite que instaladores e ferramentas de criação de imagens funcionem. 

     1.  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.10.20260325. Isso significaria que o `build` contêiner seria executado como a AL2023 versão mais recente, mas construiria o contêiner básico a partir de 2023.10.20260325, independentemente da versão atual. AL2023 

         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. 

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

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

1. 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
   ```

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

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

1. 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
   ```

Para um exemplo mais prático, o procedimento a seguir cria um contêiner para um aplicativo C que exibe `Hello World!`.

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

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

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

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

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