Esta é apenas uma demonstração simples para obter uma compreensão básica de como o Docker funciona passo a passo. Aprendi docker assim e fiz este repositório para resolver alguns problemas que enfrentei durante minha experiência de aprendizado para que pudesse ajudar outros iniciantes. Espero que você goste de aprender. Se você gostou dê um like no GitHub e apoie meu trabalho.
Importante: - Ao ver o tamanho do leia-me, você pode ter dúvidas, mas, para ser honesto, se trabalhar desde o início, não terá nenhum problema e aprenderá ao longo do caminho.
A Wikipedia define Docker como
é um conjunto de produtos de plataforma como serviço (PaaS) que usa virtualização em nível de sistema operacional para entregar software em pacotes chamados contêineres. Os contêineres são isolados uns dos outros e agrupam seus softwares, bibliotecas e arquivos de configuração; eles podem se comunicar entre si por meio de canais bem definidos. Todos os contêineres são executados por um único kernel de sistema operacional e, portanto, usam menos recursos que as máquinas virtuais.
Docker ajuda você a implantar seus aplicativos com mais eficiência em uma sandbox (chamada de contêineres) para rodar no sistema operacional host, ou seja, Mac. A principal vantagem do docker é que ele permite empacotar software com todas as suas dependências em uma única unidade padronizada.
O contêiner é uma solução para fazer com que o software funcione sem problemas ao ser movido de um ambiente de computação para outro. Isso pode ser de um ambiente de teste para produção ou talvez de um laptop para outro laptop com outro sistema operacional.
Os contêineres fornecem um mecanismo de empacotamento lógico no qual seus aplicativos podem ser abstraídos do ambiente em que são executados. A principal diferença é que cada contêiner não requer um sistema operacional completo. Todos os contêineres em um único host compartilhando um único sistema operacional. Isso ajuda a liberar grandes quantidades de recursos do sistema, como CPU e RAM.
Quando terminar de instalar o Docker, teste a instalação do Docker executando o seguinte:
docker run hello-world
Hello from Docker.
This message shows that your installation appears to be working correctly.
...Dockerfile é um documento de texto que contém todos os comandos que você pode chamar na linha de comando para criar uma imagem. Crie um arquivo hello.js e copie este código nele. Aqui escrevemos um código JS simples para mostrar Hello World em localhost:8888 . var http = require( " http " ) ;
http.createServer(function (request, response) {
response.writeHead(200, { ' Content-Type ' : ' text/plain ' }) ;
response.end( ' Hello Worldn ' ) ;
}).listen(8888) ;
// Console will print the message
console.log( ' Server running at http://127.0.0.1:8888/ ' ) ;Dockerfile e copie este código nele. FROM node:8
LABEL maintainer= " [email protected] "
RUN npm install
ADD hello.js /hello.js
EXPOSE 8888
ENTRYPOINT [ " node " , " hello.js " ]Mesmo que este seja o primeiro Dockerfile que você já viu, eu diria que você pode adivinhar o que está acontecendo aqui. As instruções do Dockerfile são FROM, ENV, LABEL, RUN , ADD , EXPOSE e ENTRYPOINT; eles estão em maiúsculas, mas isso é uma convenção, não um requisito.
Em alto nível, este Dockerfile fornece instruções como começar com a imagem do nó, adicionar “[email protected]” como mantenedor, executar npm install para instalar dependências, copiar o arquivo no código do aplicativo, documentar a porta de rede do aplicativo, e defina hello.js como o aplicativo padrão a ser executado.
Agora criaremos uma imagem docker em nossa máquina local. Abra seu terminal na pasta do projeto atual e execute
docker build -t helloworld . Aqui você está dizendo ao Docker para construir uma imagem chamada helloworld com base no conteúdo do diretório atual (observe o ponto (.) no final do comando build). O Docker procurará o Dockerfile no diretório e construirá a imagem com base nas instruções do arquivo.
Depois de construir a imagem docker, o próximo passo seria executar a imagem e ver se funciona:
docker run -p 8888:8888 helloworldO comando que acabamos de executar usou a porta 8888 para o servidor dentro do contêiner e expôs isso externamente na porta 8888. Vá para a URL com a porta 8888:
Parabéns! Você criou com sucesso sua primeira imagem do Docker.
As imagens Docker são como modelos de máquinas virtuais e são usadas para iniciar contêineres. Nos bastidores, eles são compostos de uma ou mais camadas somente leitura que, quando empilhadas juntas, constituem a imagem geral. Docker se encarrega de empilhar essas camadas e representá-las como um único objeto unificado. Nota: as imagens do Docker são imutáveis, o que significa que as imagens do Docker nunca podem ser alteradas. Depois de criar um, você poderá excluí-lo, mas não poderá modificá-lo.
A imagem do Docker contém todos os arquivos que você empacotou, que se tornam o sistema de arquivos do contêiner - e também contém muitos metadados sobre a própria imagem. Isso inclui um breve histórico de como a imagem foi construída. Você pode usar isso para ver cada camada da imagem e o comando que construiu a camada. Você pode verificar o histórico da imagem helloworld usando:
docker image history helloworld
IMAGE CREATED CREATED BY COMMENT
cb84eb33ca20 58 seconds ago /bin/sh -c # (nop) ENTRYPOINT ["node" "hello…
7d652a817a9f 58 seconds ago /bin/sh -c # (nop) EXPOSE 8888
334575e947c9 59 seconds ago /bin/sh -c # (nop) ADD file:b9606ef53b832e66e… Os comandos CREATED BY são as instruções do Dockerfile – há um relacionamento um para um, então cada linha no Dockerfile cria uma camada de imagem.
Primeiro, você precisa fazer login com sua conta dockerhub
docker login --username $dockerIdAgora que você está logado, você pode enviar imagens para sua conta ou para qualquer organização à qual você tenha acesso. Se você não for membro de nenhuma organização, só poderá enviar imagens para repositórios em sua conta.
Construímos uma imagem Docker chamada helloworld . Essa referência de imagem não tem um nome de conta, portanto não podemos enviá-la para nenhum registro. Não precisamos reconstruir a imagem para fornecer uma nova referência, pois as imagens podem ter várias referências. Marque sua imagem assim:
docker image tag helloworld $dockerId /helloworld:v1Agora temos uma referência de imagem com nosso Docker ID no nome da conta e efetuamos login no Docker Hub, então estamos prontos para compartilhar nossa imagem! O comando docker image push é a contrapartida do comando pull, ele carrega nossas camadas de imagem locais para o registro:
docker image push championshuttler/helloworld:v1
The push refers to a repository [docker.io/championshuttler/helloworld]
9519a21ac374: PushedPodemos colocar qualquer string em uma tag de imagem do Docker e, como já vimos, você pode ter várias tags para a mesma imagem. Usaremos isso para versionar o software em nossas imagens e permitir que os usuários façam escolhas informadas sobre o que não usarão - e para fazer nossas próprias escolhas informadas quando usarmos imagens de outras pessoas.
Muitos projetos de software usam um esquema de controle de versão numérico com pontos decimais para indicar o tamanho da mudança entre as versões, e você pode acompanhar isso com suas tags de imagem. A ideia básica é algo como [major].[minor].[patch], que tem algumas garantias implícitas. Uma versão que apenas incrementa o número do patch pode ter correções de bugs, mas deve ter os mesmos recursos da última versão; uma versão que incrementa a versão secundária pode adicionar recursos, mas não deve remover nenhum; um lançamento importante pode ter recursos completamente diferentes.
A maioria dos aplicativos não é executada em um único componente. Mesmo grandes aplicativos antigos são normalmente criados como componentes front-end e back-end, que são camadas lógicas separadas executadas em componentes distribuídos fisicamente. O Docker é ideal para executar aplicativos distribuídos – desde monólitos de n camadas até microsserviços modernos. Cada componente é executado em seu contêiner leve e o Docker os conecta usando protocolos de rede padrão. Você define e gerencia aplicativos de vários contêineres como este usando o Docker Compose. Docker Compose é uma ferramenta para definir e executar aplicativos Docker com vários contêineres. Com o Compose, você usa um arquivo YAML para configurar os serviços do seu aplicativo. Então, com um único comando, criamos e iniciamos todos os serviços da sua configuração.
O arquivo Docker Compose descreve o estado desejado do seu aplicativo – como ele deve ficar quando tudo estiver em execução. É um formato de arquivo simples onde você captura todas as opções que colocaria nos comandos de execução do contêiner do docker no arquivo Compose. Em seguida, você usa a ferramenta Docker Compose para executar o aplicativo. Ele descobre quais recursos do Docker precisa – que podem ser contêineres, redes ou volumes – e envia solicitações à API do Docker para criá-los. O nome padrão para o arquivo YAML do Compose é docker-compose.yml . No entanto, podemos usar o sinalizador -f para especificar nomes de arquivos personalizados.
Vamos começar.
Abaixo, o código mostra um arquivo Docker Compose muito simples que define um pequeno aplicativo Flask com dois serviços (web-frontend e redis). O aplicativo é um servidor web simples que conta o número de visitas e armazena o valor no Redis.
version: " 3.5 "
services:
web-frontend:
build: .
command: python app.py
ports:
- target: 8888
published: 8888
networks:
- counter-net
volumes:
- type: volume
source: counter-vol
target: /code
redis:
image: " redis:alpine "
networks:
counter-net:
networks:
counter-net:
volumes:
counter-vol: A chave version é necessária e deve sempre estar na primeira linha do arquivo. Isso explica a versão do formato Compose file (basicamente a API).
A chave services de nível superior é onde definimos os diferentes serviços de aplicação. O exemplo que estamos usando define dois serviços; um front-end da web chamado web-frontend e um banco de dados na memória chamado Redis. O Compose implantará cada um desses serviços como seu contêiner.
A chave networks de nível superior diz ao Docker para criar novas redes. Por padrão, o Compose criará redes bridge. Estas são redes de host único que só podem conectar contêineres no mesmo host.
Dentro da definição do serviço web-frontend, damos ao Docker as seguintes instruções:
Implantaremos o aplicativo definido no arquivo Compose da seção anterior. Para fazer isso, você precisará dos quatro arquivos a seguir de https://github.com/championshuttler/counter-app:
Clone o repositório Git localmente.
git clone https://github.com/championshuttler/counter-app.gitVamos descrever rapidamente cada arquivo:
app.py é o código do aplicativo (um aplicativo Python Flask).docker-compose.yml é o arquivo Docker Compose que descreve como o Docker deve implantar o aplicativo.Dockerfile descreve como construir a imagem para o serviço web-frontend.requirements.txt lista os pacotes Python necessários para o aplicativo. Vamos usar o Compose para abrir o aplicativo. Você deve executar todos estes comandos a seguir no diretório counter-app :
docker-compose up &O aplicativo levará alguns segundos para aparecer e a saída pode ser bastante detalhada.
Com o aplicativo implantado com sucesso, você pode apontar um navegador da web para seu host Docker na port 5000 e ver o aplicativo em toda a sua glória.
Você achou o tutorial uma bagunça completa ou se divertiu e aprendeu alguma coisa? Envie suas ideias diretamente para mim ou apenas crie um problema. Encontre-me no Twitter também, fique à vontade para tirar dúvidas.
Eu adoraria ouvir sobre sua experiência com este tutorial. Espero que você tenha gostado de aprender. Se você gostou, dê um like no GitHub e apoie meu trabalho.
