Um dos passos mais importantes

quando a gente fala
da utilização de Docker

é justamente aprender
a criar o nosso próprio Docker,

ou pelo menos a nossa própria imagem.

Para isso, a gente vai ter que utilizar
algumas ferramentas.

A primeira e provavelmente mais importante
nesse processo vai ser o Dockerfile.

Ele é basicamente um arquivo
que vai permitir que eu passe

instruções para o Docker
de como ele deve construir aquela imagem.

Antes de mais nada,
eu vou precisar pelo menos de algum código

para que eu consiga colocar
em desenvolvimento.

Para isso eu peguei um código zinho
bem simples de resolver,

baseado aí em onde é
basicamente uma página que tem

um campinho de preenchimento de busca
e um botãozinho.

Mas essa função não tem nada programado.

É realmente só pra a gente ter um código
para estar utilizando.

Nesse caso a gente vai estar
utilizando um código em Node.

E justamente por isso eu preciso utilizar
como base para a minha imagem

uma imagem que já tenha um load
pronto para eu poder utilizar.

Caso a gente
não ache uma imagem dessa forma,

a gente pode passar comandos
dentro de um container para que ele faça

todo o processo de instalação
daquele software

e disponibilize
todo aquele ambiente montado para a gente.

Aqui dentro da minha tela.

Eu vou ter então uma pasta chamada EPP

que eu criei dentro do meu desktop e nela
eu vou ter alguns arquivos

o Yarn lock, o pack,

a pasta CRC e a pasta espec.

São justamente conteúdos que eu tenho
dessa minha aplicação.

Se eu abro, por exemplo aqui o src,
eu vou ter um index ponto js

que vai ser justamente
o arquivo inicial da minha aplicação.

Aqui nessa pasta eu ainda tenho o arquivo
chamado Dockerfile.

Esse é o arquivo que vai trazer
todas as instruções

que o Docker precisa
para construir a nossa imagem.

Existem algumas características
muito importantes

que a gente tem que se atentar nele.

A primeira delas é que esse arquivo

não tem extensão.

A segunda é que ele sempre vai começar

com D maiúsculo e Doc
e vai estar escrito tudo junto.

Eu preciso justamente prestar atenção
em todos esses padrões

para que eu não impeça o Docker

de achar o arquivo e assim começar
o processo de build da imagem.

Agora como que eu valido
isso aqui dentro dos meus arquivos?

Basta ouvir na aba de visualização
do Explorer no Windows

e marcar a opção Fill

Extensions
ou mostrar extensões de arquivo.

Note que agora

todos os meus arquivos
ganharam uma extensão.

Menos no Dockerfile.

Pode ser que quando você tenha criado
o arquivo utilizando, por exemplo,

o bloco de notas,
ele tivesse mostrado uma opção como txt.

Caso ele tenha aparecido como txt.

No final, basta apertar a tecla F2
e renomear o arquivo

excluindo o ponto txt
e deixando apenas Dockerfile.

O Windows vai pedir que você confirme
que aquele arquivo

não vai ter uma extensão, basta confirmar
e seguir para as próximas etapas.

Quando a gente abre o Dockerfile
dentro de um bloco de notas,

a gente vai ter uma estrutura
até bem simples.

A primeira coisa que a gente vai ver
é justamente um comentário

definindo o qual tipo de sintaxe
a gente está utilizando para construção

desse arquivo.

Nesse caso, uma sintaxe de versão um.

As linhas de comando que definem a sintaxe
estão lá na documentação do Docker.

Por hora,
você pode simplesmente copiar essa linha

para todos os seus arquivos
e tudo vai correr sem maiores problemas.

Agora, caso você se torne
um usuário avançado de Docker,

algumas funções só vão estar disponíveis
em versões específicas do Docker File,

então você vai ter que ficar atento
a qual tipo de Docker vai utilizar

para poder criar exatamente o container
da forma que você precisa.

Logo em seguida
eu tenho um comando chamado FROM.

Esse comando serve para eu especificar

qual a imagem de base
que eu vou estar utilizando.

Nesse caso, uma imagem chamada Node

na versão 12 ao painel.

É justamente aqui, por exemplo,
que caso queira criar um container

totalmente do zero, utilizando
só um sistema operacional de base,

eu vou conseguir especificar que eu quero
esse sistema operacional.

Se eu quisesse, por exemplo,
criar um servidor Apache do zero,

eu poderia fazer um from Ubuntu
e nos comandos

que se seguem fazer todo o passo
a passo de instalação do Apache.

Nesse caso, a gente já está reaproveitando
parte da estrutura do Node

que já está pronta e aí
eu só preciso rodar alguns poucos comandos

e copiar os meus arquivos
para dentro do container.

Nosso próximo passo então é rodar a PK

Red pra
garantir aí que eu tenho um Python dois,

o compilador C e o
make dentro da minha máquina.

Nosso próximo passo então

vai ser criar um diretório de trabalho,

nesse caso chamado EPP.

Esse diretório de trabalho
vai basicamente informar para o container

qual pasta
ele deve utilizar para poder trabalhar.

Note que todo nosso conteúdo do arquivo

está dentro de uma pasta chamada EPP.

Dessa forma eu vou conseguir navegar
para dentro dessa pasta,

utilizar ela como parte da padrão
e a partir de

então começar a executar os demais
comandos.

O comando copy serve justamente para
copiar arquivos para dentro do container.

Ele vai copiar todos os arquivos
da pasta que eu me encontro,

por isso o ponto para a pasta que eu
vou estar utilizando dentro do contêiner.

Por isso eu vou utilizar.

Ponto novamente
e aqui vai vir um ponto bem interessante.

A cópia do arquivo não é exatamente
uma boa prática, como a gente viu.

Se a gente não souber
utilizar o armazenamento de arquivos

de forma correta, isso vai atrapalhar
o bom funcionamento de um ponteiro.

A questão nesse caso é que,
como eu estou criando um container novo,

eu preciso passar a todos os códigos
que vão servir de base para ele.

Então eu posso copiar esses arquivos
sem a menor dor de cabeça,

já que eles vão passar
a ser parte fundamental

de todo o container que eu estou criando.

O passo seguinte,
então, é garantir que esse meu sistema

esteja utilizando o ambiente de produção.

Para isso,
eu posso executar um Warning Stall.

Esse comando é um comando
que pertence ao ambiente novo e serve

basicamente para instalar
todos os pacotes necessários

e preparar o ambiente para a execução
daquela minha aplicação.

Em seguida, eu vou utilizar o C MD,

que é basicamente uma forma de criar

linhas de comando dentro do container.

Nesse caso, eu estou chamando o comando
node e informando para ele

que o arquivo de origem da minha aplicação
está dentro da pasta SCR

index.

E esse é exatamente
o caminho que a gente checou agora a pouco

de onde estava o index da minha aplicação.

Então, a partir do momento que eu copiei
esses dados para dentro do container,

eu agora mostrei para o novo de
como executá lo.

Por fim, eu estou fazendo um ex
pouso da porta 3000.

Esse comando serve justamente
para eu informar

que eu vou ter que acessar
uma porta desse conta e dessa forma,

na hora que eu for criar o container para
colocá lo em execução, o Docker vai saber

que eu posso ter uma conexão de rede ali
e vai permitir a criação dessa interação.

Outro detalhe muito importante é que
eu tenho duas formas de executar comandos.

O primeiro é a partir do comando run.

O run vai simplesmente executar
aquela linha

de comando dentro do meu container.

Na hora que eu estiver fazendo
toda a parte de construção dele.

Enquanto isso, sem MD,
vão ser comandos que vão ser executados

posteriores à criação do meu container.

Dessa forma, quando eu crio lá o C.

MD chamando um comando novo
e passando o index,

toda vez que esse container for colocado
em execução, esse comando vai ser chamado.

Agora que todo esse processo
está finalizado,

eu posso utilizar esses arquivos

para construir o meu container,
utilizando então o prompt de comando.

Eu vou poder recorrer a uma função chamada

Docker build.

Esse comando é um comando bem simples
e não tem muita coisa que a gente deve

configurar nele.

Nesse caso, por exemplo,
a gente só vai nomear a imagem

e em seguida informar o endereço
do Dockerfile que vai ser utilizado.

Para isso
eu vou informar o menos ter seguido

do nome da imagem,

nesse caso vou chamar ela de Olá

e em seguida eu vou informar um ponto.

A função desse ponto
é para informar que eu já estou na pasta

aonde eu tenho o Dockerfile,
caso não esteja nessa pasta,

ao invés de informar o ponto eu vou ter
que informar todo o endereçamento de pasta

e esse endereçamento
vai variar entre sistemas operacionais.

A forma mais fácil
então é utilizar os comandos de navegação

de terminal como CD
para poder navegar pelos diretórios

e chegando no diretório
que tem o Dockerfile

ou simplesmente executar o Docker build
com o ponto no final.

Executando então o processo de build,

várias coisas vão ser executadas.

A primeira delas
é todo download de imagens,

seguido da construção das aplicações

e todo o teste de funcionamento
para ver se o comando inicial

vai ser executado com sucesso.

Caso você
possua alguma falha nesse processo,

você pode recorrer ao Docker Logs.

Esse é um comando que permite a gente
checar logo o ambiente Docker.

Inclusive é legal que você pode utilizar
ele para checar logs

individualmente de cada contêiner
com o processo de build concluído.

O Docker sempre vai perguntar se você não
quer fazer um scan de vulnerabilidades.

Nesse caso, não vai ser preciso.

A única coisa que nos falta agora

é colocar justamente
esse container em execução.

Para isso a gente vai recorrer ao comando
docker run.

Só que dessa vez eu vou ter que passar
alguns parâmetros de execução para ele.

O primeiro parâmetro vai ser justamente
para garantir

que essa imagem vai ficar em execução
o tempo todo.

Para isso, vou utilizar ao menos o D,

enquanto o segundo parâmetro menos p,

vai ser para informar o apontamento de
portas de rede.

Dessa forma,
todo o conteúdo da minha aplicação

vai ficar disponível
para acesso para executar então

o container que a gente acabou de criar,
eu vou fazer um Docker run

em menos de

menos P para informar a porta

e nesse caso eu expus a porta 3000.

Então vou utilizar 3002 pontos, 3000.

A razão de eu ter que repetir O31000

duas vezes
é porque eu estou falando de duas portas.

A primeira é a porta na minha máquina base

e a segunda é a porta do meu container,
que específico por exemplo,

a primeira porta,
que é a da máquina base, como 80.

Ela vai apontar um acesso

realizado na porta 80 do meu servidor base

para a porta 3000 do meu container.

Isso é algo que a gente tem que prestar
bastante atenção.

Às vezes,
quando a gente vai criar uma aplicação,

a gente tem vários containers
que tem expostas a porta 80

e eu posso apontar diversas portas
para dentro desses containers,

utilizando numerações diferentes
no meu rosto base.

O próximo passo então é informar o nome da
minha imagem, nesse caso o LA

colocando a imagem em execução

eu vou receber o código de validação dela

e se eu executar um Docker PRS?

Note que essa minha imagem
já se encontra em execução

e me informando que a porta 3000
está apontando para a porta

3000 do contêiner.

O último passo
então, é abrir o navegador web

e acessar
justamente a nossa máquina na porta 3000.

O IP que eu informei aqui 127,0

ponto zero
ponto um é o que se chama de local Rust.

Ele representa a própria máquina na rede.

Outra forma que você teria era escrever
por extenso local rows de 2,3000.

Qualquer uma das duas formas

já faria com que toda a interface
funcionasse normalmente.

No nosso caso, após acessar a aplicação,

todo o código que a gente criou e compilou
já está aqui disponível para uso

e eu consigo, por exemplo, ir adicionando
itens dentro dessa minha aplicação.

Esse é um exemplo de uma aplicação
bem simples,

só pra gente entender como é que eu começo
a construir todo esse ambiente.

A partir de agora,
você pode utilizar esses conhecimentos

para começar a renderizar
as suas próprias aplicações

e com isso entender um pouco mais
de como todo esse ecossistema funciona.