Criando uma imagem do Docker do zero

A principal vantagem do Docker em relação a qualquer outra tecnologia de contêinerização é que o Docker seja destinado a desenvolvedores e suas aplicações no upstack. Embora as tecnologias adequadas de contêinerização como o LXC, zonas e prisões sejam alvo do ponto de vista das operações, ou, para simplificar, essas plataformas substituem as máquinas virtuais em execução na nuvem. Onde, o Docker é um substituto para pacotes e binários executáveis.

Speaky, Docker está se tornando cada vez mais como um gerente de pacotes universal que funciona em todas as plataformas Linux possíveis. É preciso recipientes e os usa para resolver um problema completamente diferente que os desenvolvedores enfrentam. O problema é que os desenvolvedores usam seu sistema operacional de desktop (como Windows, MacOS ou Linux com uma tonelada de pacotes relacionados à área de trabalho) para gravar aplicativos. O aplicativo que eles escrevem geralmente são executados em um sistema operacional completamente diferente em um servidor em algum lugar com alguma distribuição do Linux completamente diferente do do laptop do desenvolvedor.

Com o Docker, a idéia é que seu aplicativo seja embalado como uma imagem do Docker. É o trabalho do Docker pegar esta imagem e executá -la como um aplicativo de contêiner para você. Ser contêiner significa que o aplicativo e suas dependências serão executadas em um ambiente isolado que pode diferir completamente do laptop do desenvolvedor e até do servidor de produção. Enquanto os dois apoiarem o Docker, ambos podem executar o mesmo aplicativo da mesma maneira.

Anatomia de uma imagem do Docker

Como mencionado anteriormente, um aplicativo Docker será executado em um ambiente acordado. Agora a questão é como criamos esse ambiente? A maioria das imagens de aplicativos importaria uma imagem base do docker e construiria seu aplicativo em cima dela.

Os aplicativos são feitos de camadas de software. Uma imagem de contêiner do WordPress é construída usando uma imagem de contêiner httpd que, por sua vez, é construída sobre uma imagem do Ubuntu. A imagem sobre a qual uma imagem mais recente é construída é conhecida como a imagem pai na terminologia do Docker. No Dockerfile (vamos chegar ao que significa um DockerFile, um pouco mais tarde), essa imagem pai é mencionada na parte superior do arquivo, como mostrado abaixo:

De Ubuntu: 18.04
## Resto do Dockerfile

Este DockerFile, quando executado, converte seu aplicativo em uma imagem do Docker (uma espécie de binário), que você pode empurrar para um registro de onde ele pode ser puxado para criar novos contêineres em outros lugares. No entanto, todos eles terão Ubuntu: 18.04 como imagem base e corra como se fosse um sistema Ubuntu em que eles estivessem executando.

Você deve ter notado isso ao tentar puxar uma nova imagem do Docker.

Isso mostra quantas camadas são puxadas antes que o aplicativo real (que pode ser apenas alguns megabytes de tamanho) é trazido.

Por esse motivo, gostaríamos de criar o que é conhecido como uma imagem base. Que não está construído em cima de qualquer outra coisa. A palavra -chave "Scratch" é usada para indicar que essa camada não está construída em cima de qualquer outra coisa. Igual a:

Do princípio
## Resto do DCOKERFILE

Primeiro, criaremos um aplicativo simples do Hello-World e depois descobriremos o que o resto do DockerFile será. O sistema host é Ubuntu: 18.04 LTS e estamos usando o Docker versão 17.12.1-C para o experimento.

Criando um binário estático

Os contêineres do Docker são uma coleção de processos que executam isolados do restante do sistema operacional. A única coisa que o processo está em contato é o kernel. Kernel é responsável por agendar esses processos na CPU, fazer gerenciamento de memória e algumas outras tarefas básicas de reserva.

Mas a maioria dos aplicativos de alto nível depende de muitas bibliotecas de sistemas (como glibc, musl, klibc, etc) e muitas dependências de tempo de execução, como python ou nó.Tempo de execução de JS ou Java. O aplicativo binário não tem todas as bibliotecas disponíveis dentro dele, mas quando começa a execução, chama essas bibliotecas do sistema operacional host.

Porque estamos tentando criar uma imagem do zero, não estaríamos recebendo essas gleeties. Portanto, nosso aplicativo precisa ser um arquivo estático ou um executável independente.

Vamos começar criando uma pasta chamada mydockerimage e criando um arquivo olá.CC dentro dele.

$ mkdir mydockerimage
$ CD MyDockerImage
$ toque olá.cc

Open Hello.CC usando seu editor de texto favorito e adicione as seguintes linhas dentro dele.

#incluir
usando namespace std;
int main ()
cout << "Hello! This message is coming from a container \n ";
retornar 0;

Este é um programa C ++ simples que imprime “Olá! Esta mensagem… "

Por motivos discutidos anteriormente, vamos compilar isso usando a bandeira estática. O compilador que está sendo usado é G ++ (Ubuntu 7.3.0-16buntu3) 7.3.0.

Para compilar o programa, no mesmo diretório executa o seguinte comando:

$ g ++ -o Olá -static Hello.cc

Isso cria um arquivo executável binário "Hello" no mesmo diretório. Esse é o nosso arquivo estático. Teste se está sendo executado como pretendido mencionando o nome do arquivo no terminal.

$ ./olá

Agora estamos prontos para recipilar este programa simples.

Dockerfile

O DockerFile consiste em um conjunto de regras que leva seus arquivos de aplicativo (como binários, arquivos de origem etc.) junto com vários parâmetros de configuração, como o layout do sistema de arquivos, portas expostas, etc. e as transforma em um arquivo de imagem do docker. Você pode compartilhar o arquivo de imagem com quem quiser executar esse aplicativo.

Não vamos cavar em todas as opções disponíveis para o Dockerfile, em vez disso, escreveremos um Dockerfile muito minimalista. No mesmo diretório, onde o seu hello executável reside, crie um arquivo vazio chamado Dockerfile.

$ touch dockerfile

Abra -o com seu editor de texto favorito e escreva as seguintes linhas para ele:

Do princípio
Adicionar olá /
Cmd ["/hello"]

arranhar não é uma imagem pai. Em vez disso, indica o Docker que a imagem não está construída sobre nenhuma outra imagem. É construído do zero. Adicionar comando levaria o binário estático nomeado oláNo diretório atual e adicione -o ao diretório raiz do arquivo de imagem. Quando finalmente executamos um contêiner com base nesta imagem, o hello executável será visto dentro do próprio diretório raiz em /olá.

Por fim, a linha CMD tem uma string "/olá" Esta string será executada como um comando shell sempre que um contêiner for criado a partir desta imagem, portanto o arquivo binário que adicionamos ao nosso contêiner e imprimimos a mensagem que escrevemos em nosso aplicativo.

Vamos construir a imagem invocando o Docker Build comando que passaria pelo conteúdo do Dockerfile e geraria a imagem. Execute o seguinte comando no mesmo diretório que o Dockerfile e o Binário Executável.

$ Docker Build -Vaga olá .

O -Tag Hello Flag define o nome da imagem para olá e o ponto ( ““.”) No final diz Docker Build Para procurar o diretório atual para o Dockerfile e o conteúdo relacionado.

Executando o contêiner do Docker

Para verificar se a imagem que acabamos de criar aparece na lista de imagens, execute:

$ Docker Images

Observe quão pequena é a imagem Hello quando comparada a outras imagens. De qualquer forma, está pronto para ser executado como um contêiner,

$ Docker Run Hello

É isso! Você criou seu primeiro recipiente minimalista do zero.

Outras opções

Enquanto criar imagens do zero é sempre uma opção, as pessoas geralmente tendem a criar imagens de outras distantes leves Linux. Por exemplo, imagens como Alpine e BusyBox são ambientes realmente leves com bibliotecas menores como Musl em vez de glibc.

Usando -os como sua imagem pai usando “De Alpine: mais recente” resultaria em imagens menores também. Como as imagens básicas têm apenas 2-5 MB de tamanho. Deixe -nos saber se houver algum tópico relacionado ao Docker que você possa querer que abordemos a seguir. Você pode entrar em contato conosco no Twitter, Facebook ou assinar -nos por e -mail.