Como criar suas próprias imagens da base do Docker a partir do "zero"

As imagens do Docker são criadas a partir de um Dockerfile que define uma imagem base e uma série de instruções que adicionam suas próprias camadas do sistema de arquivos. O que acontece se você quiser fazer sua própria “ imagem de base ” no entanto? Veja como começar do zero e criar um sistema de arquivos contêiner completo do zero.

O que é uma imagem?

As imagens do Docker geralmente usam uma distribuição Linux popular como imagem base. Se você escreveu FROM ubuntu: latest, FROM debian: latest ou FROM alpine: latest, você usou um sistema operacional como sua base. Você também pode usar uma imagem pré-configurada para uma determinada linguagem de programação ou estrutura, como FROM php: 8.0 ou FROM node: 16.

Todas essas imagens fornecem um ponto de partida útil para seus aplicativos. Eles vêm com utilitários Unix comuns e pacotes de software importantes. Porém, tudo isso aumenta o tamanho da imagem final. Uma imagem realmente mínima deve ser construída construindo seu próprio sistema de arquivos a partir dos primeiros princípios.

O “ scratch ” Imagem

O Docker fornece uma imagem base especial que indica que você deseja controlar a primeira camada do sistema de arquivos. Esta é a camada mais inferior de sua imagem, geralmente definida pela imagem de base indicada por sua instrução FROM.

Quando você deseja criar uma imagem “ do zero, ” escrever do zero em seu Dockerfile é a maneira de fazer isso! Isso fornece um sistema de arquivos que é uma folha em branco para começar.

 DO zero 

Publicidade

Você deve então usar o resto do Dockerfile normalmente para preencher o sistema de arquivos do contêiner com os binários e bibliotecas de que precisa.

O que é “ scratch ”?

A “ imagem de risco ” parece uma imagem normal do Docker. Ele está até listado no Docker Hub. scratch não é realmente uma imagem, embora – é uma palavra-chave reservada que denota a camada mais baixa do sistema de arquivos de uma imagem em funcionamento. Todas as imagens do Docker se assentam no zero como sua base comum.

Você não pode &’ t docker pull scratch e não é possível executar contêineres usando-o. Ele representa uma camada de imagem vazia, portanto, não há nada para o Docker executar. As imagens também não podem ser marcadas como zero devido à sua natureza reservada.

O que pode ser adicionado a imagens baseadas em scratch?

Você não precisa de muito para construir uma imagem funcional sobre o zero. Tudo que você precisa adicionar é um binário Linux compilado estaticamente que você pode usar como o comando da sua imagem.

Aqui está uma demonstração funcional que executa um minúsculo “ hello world ” programa compilado de C:

#include < stdio.h >   int main & # 40; & # 41; & # 123; printf & # 40; " Hello World " & # 41 ;; return0; & # 125;

Compile seu código C para um binário:

 gcc -o helloworld hello.c 

Execute seu binário e observe que “ hello world ” é impresso em seu terminal:

 ./ helloworld 

Publicidade

Agora você pode criar um contêiner Docker baseado em scratch que executa seu binário:

 DO zero COPIAR helloworld / CMD ["helloworld"] 

Construa sua imagem:

 docker build -t hello: mais recente. 

A inspeção da imagem com o docker inspect mostrará que ela possui uma única camada. O sistema de arquivos desta imagem contém apenas um arquivo, o binário helloworld.

Agora execute um contêiner usando sua imagem:

 docker executado olá: mais recente 

Você verá “ olá, mundo ” em seu terminal enquanto seu binário compilado é executado. Sua imagem baseada em scratch contém apenas seu binário, portanto, terá apenas alguns KBs de tamanho. Usar qualquer imagem de base de sistema operacional aumentaria isso para vários megabytes, mesmo com uma distribuição mínima como Alpine.

Praticamente todas as imagens terão algumas dependências além de um binário estático simples. Você precisará adicioná-los à sua imagem como parte do Dockerfile. Lembre-se de que nenhuma das ferramentas que você considera normais nas distribuições Linux padrão estará disponível até que você as adicione manualmente ao sistema de arquivos da imagem.

Quando usar o Scratch?

A decisão de começar do zero deve se basear nas dependências do seu aplicativo e nos seus objetivos em relação à portabilidade da imagem. Imagens criadas do zero são mais adequadas para hospedar binários compilados estaticamente onde o tamanho da imagem e o tempo de criação são importantes.

O scratch fornece uma lousa limpa para trabalhar, portanto, requer algum investimento inicial para escrever corretamente seu Dockerfile e mantê-lo ao longo do tempo. Alguns comandos do Docker, como attach, não funcionam por padrão, pois não haverá shell dentro do seu contêiner, a menos que você adicione um.

Publicidade

Usar scratch pode ser mais problemático do que vale quando você está usando linguagens interpretadas com fortes dependências ambientais. Você precisará atualizar continuamente sua imagem de base para fazer referência às versões mais recentes desses pacotes. Geralmente é mais conveniente e de fácil manutenção usar uma variação mínima de uma imagem base do Docker Hub existente.

Resumo

Do zero em um Dockerfile indica que você deseja iniciar a partir de um sistema de arquivos vazio onde você está no controle de todas as camadas adicionadas. Ele facilita imagens altamente simplificadas e eliminadas de tudo, exceto das dependências de que seu aplicativo precisa.

É improvável que a maioria dos desenvolvedores use o scratch diretamente, pois ele é inadequado para a maioria dos casos de uso de contêiner. Você pode optar por usá-lo se quiser colocar em contêineres binários estáticos autocontidos com poucos requisitos ambientais.

scratch também funciona como um indicador claro da diferença entre “ contêineres ” e VMs. Uma imagem contendo apenas um arquivo executável é um contêiner do Docker utilizável, pois o processo é executado no kernel do seu host. Uma VM regular precisa ser inicializada independentemente de seu host, portanto, deve incluir um kernel completo do sistema operacional em sua imagem.