0:00:09.142,0:00:10.710
Um dos passos mais importantes

0:00:10.710,0:00:13.279
quando a gente fala[br]da utilização de Docker

0:00:13.279,0:00:16.850
é justamente aprender[br]a criar o nosso próprio Docker,

0:00:16.950,0:00:20.320
ou pelo menos a nossa própria imagem.

0:00:20.420,0:00:23.423
Para isso, a gente vai ter que utilizar[br]algumas ferramentas.

0:00:23.623,0:00:29.829
A primeira e provavelmente mais importante[br]nesse processo vai ser o Dockerfile.

0:00:29.896,0:00:33.400
Ele é basicamente um arquivo[br]que vai permitir que eu passe

0:00:33.400,0:00:37.771
instruções para o Docker[br]de como ele deve construir aquela imagem.

0:00:37.837,0:00:41.708
Antes de mais nada,[br]eu vou precisar pelo menos de algum código

0:00:41.708,0:00:45.311
para que eu consiga colocar[br]em desenvolvimento.

0:00:45.378,0:00:49.349
Para isso eu peguei um código zinho[br]bem simples de resolver,

0:00:49.549,0:00:53.186
baseado aí em onde é[br]basicamente uma página que tem

0:00:53.186,0:00:56.890
um campinho de preenchimento de busca[br]e um botãozinho.

0:00:56.956,0:00:59.459
Mas essa função não tem nada programado.

0:00:59.459,0:01:02.462
É realmente só pra a gente ter um código[br]para estar utilizando.

0:01:02.629,0:01:06.499
Nesse caso a gente vai estar[br]utilizando um código em Node.

0:01:06.599,0:01:11.471
E justamente por isso eu preciso utilizar[br]como base para a minha imagem

0:01:11.538,0:01:15.442
uma imagem que já tenha um load[br]pronto para eu poder utilizar.

0:01:15.542,0:01:18.344
Caso a gente[br]não ache uma imagem dessa forma,

0:01:18.344,0:01:22.715
a gente pode passar comandos[br]dentro de um container para que ele faça

0:01:22.715,0:01:25.919
todo o processo de instalação[br]daquele software

0:01:25.985,0:01:29.522
e disponibilize[br]todo aquele ambiente montado para a gente.

0:01:29.589,0:01:31.591
Aqui dentro da minha tela.

0:01:31.591,0:01:34.327
Eu vou ter então uma pasta chamada EPP

0:01:34.327,0:01:40.733
que eu criei dentro do meu desktop e nela[br]eu vou ter alguns arquivos

0:01:40.800,0:01:43.703
o Yarn lock, o pack,

0:01:43.703,0:01:46.706
a pasta CRC e a pasta espec.

0:01:46.773,0:01:51.177
São justamente conteúdos que eu tenho[br]dessa minha aplicação.

0:01:51.244,0:01:56.282
Se eu abro, por exemplo aqui o src,[br]eu vou ter um index ponto js

0:01:56.449,0:02:02.322
que vai ser justamente[br]o arquivo inicial da minha aplicação.

0:02:02.422,0:02:06.092
Aqui nessa pasta eu ainda tenho o arquivo[br]chamado Dockerfile.

0:02:06.292,0:02:09.362
Esse é o arquivo que vai trazer[br]todas as instruções

0:02:09.362,0:02:13.366
que o Docker precisa[br]para construir a nossa imagem.

0:02:13.466,0:02:16.102
Existem algumas características[br]muito importantes

0:02:16.102,0:02:18.171
que a gente tem que se atentar nele.

0:02:18.171,0:02:20.740
A primeira delas é que esse arquivo

0:02:20.740,0:02:24.177
não tem extensão.

0:02:24.244,0:02:26.446
A segunda é que ele sempre vai começar

0:02:26.446,0:02:30.917
com D maiúsculo e Doc[br]e vai estar escrito tudo junto.

0:02:31.017,0:02:34.521
Eu preciso justamente prestar atenção[br]em todos esses padrões

0:02:34.621,0:02:36.289
para que eu não impeça o Docker

0:02:36.289,0:02:40.193
de achar o arquivo e assim começar[br]o processo de build da imagem.

0:02:40.293,0:02:45.365
Agora como que eu valido[br]isso aqui dentro dos meus arquivos?

0:02:45.431,0:02:49.669
Basta ouvir na aba de visualização[br]do Explorer no Windows

0:02:49.769,0:02:51.971
e marcar a opção Fill

0:02:51.971,0:02:56.142
Extensions[br]ou mostrar extensões de arquivo.

0:02:56.209,0:02:57.143
Note que agora

0:02:57.143,0:03:00.146
todos os meus arquivos[br]ganharam uma extensão.

0:03:00.213,0:03:02.348
Menos no Dockerfile.

0:03:02.348,0:03:06.252
Pode ser que quando você tenha criado[br]o arquivo utilizando, por exemplo,

0:03:06.252,0:03:11.791
o bloco de notas,[br]ele tivesse mostrado uma opção como txt.

0:03:11.991,0:03:13.927
Caso ele tenha aparecido como txt.

0:03:13.927,0:03:18.231
No final, basta apertar a tecla F2[br]e renomear o arquivo

0:03:18.331,0:03:22.835
excluindo o ponto txt[br]e deixando apenas Dockerfile.

0:03:22.902,0:03:25.972
O Windows vai pedir que você confirme[br]que aquele arquivo

0:03:25.972,0:03:30.877
não vai ter uma extensão, basta confirmar[br]e seguir para as próximas etapas.

0:03:30.944,0:03:34.380
Quando a gente abre o Dockerfile[br]dentro de um bloco de notas,

0:03:34.380,0:03:36.950
a gente vai ter uma estrutura[br]até bem simples.

0:03:36.950,0:03:41.187
A primeira coisa que a gente vai ver[br]é justamente um comentário

0:03:41.187,0:03:45.425
definindo o qual tipo de sintaxe[br]a gente está utilizando para construção

0:03:45.425,0:03:46.659
desse arquivo.

0:03:46.659,0:03:49.562
Nesse caso, uma sintaxe de versão um.

0:03:49.562,0:03:54.634
As linhas de comando que definem a sintaxe[br]estão lá na documentação do Docker.

0:03:54.701,0:03:57.403
Por hora,[br]você pode simplesmente copiar essa linha

0:03:57.403,0:04:02.508
para todos os seus arquivos[br]e tudo vai correr sem maiores problemas.

0:04:02.609,0:04:06.179
Agora, caso você se torne[br]um usuário avançado de Docker,

0:04:06.179,0:04:12.185
algumas funções só vão estar disponíveis[br]em versões específicas do Docker File,

0:04:12.252,0:04:17.023
então você vai ter que ficar atento[br]a qual tipo de Docker vai utilizar

0:04:17.090,0:04:21.461
para poder criar exatamente o container[br]da forma que você precisa.

0:04:21.561,0:04:25.465
Logo em seguida[br]eu tenho um comando chamado FROM.

0:04:25.531,0:04:28.268
Esse comando serve para eu especificar

0:04:28.268,0:04:31.271
qual a imagem de base[br]que eu vou estar utilizando.

0:04:31.371,0:04:34.574
Nesse caso, uma imagem chamada Node

0:04:34.674,0:04:37.377
na versão 12 ao painel.

0:04:37.377,0:04:41.047
É justamente aqui, por exemplo,[br]que caso queira criar um container

0:04:41.147,0:04:45.685
totalmente do zero, utilizando[br]só um sistema operacional de base,

0:04:45.752,0:04:49.389
eu vou conseguir especificar que eu quero[br]esse sistema operacional.

0:04:49.622,0:04:53.092
Se eu quisesse, por exemplo,[br]criar um servidor Apache do zero,

0:04:53.192,0:04:57.397
eu poderia fazer um from Ubuntu[br]e nos comandos

0:04:57.397,0:05:02.268
que se seguem fazer todo o passo[br]a passo de instalação do Apache.

0:05:02.368,0:05:06.839
Nesse caso, a gente já está reaproveitando[br]parte da estrutura do Node

0:05:06.906,0:05:11.411
que já está pronta e aí[br]eu só preciso rodar alguns poucos comandos

0:05:11.411,0:05:14.414
e copiar os meus arquivos[br]para dentro do container.

0:05:14.580,0:05:18.551
Nosso próximo passo então é rodar a PK

0:05:18.551,0:05:23.122
Red pra[br]garantir aí que eu tenho um Python dois,

0:05:23.222,0:05:27.827
o compilador C e o[br]make dentro da minha máquina.

0:05:27.927,0:05:30.029
Nosso próximo passo então

0:05:30.029,0:05:33.566
vai ser criar um diretório de trabalho,

0:05:33.633,0:05:36.002
nesse caso chamado EPP.

0:05:36.002,0:05:40.306
Esse diretório de trabalho[br]vai basicamente informar para o container

0:05:40.406,0:05:43.409
qual pasta[br]ele deve utilizar para poder trabalhar.

0:05:43.409,0:05:46.412
Note que todo nosso conteúdo do arquivo

0:05:46.479,0:05:49.382
está dentro de uma pasta chamada EPP.

0:05:49.382,0:05:52.785
Dessa forma eu vou conseguir navegar[br]para dentro dessa pasta,

0:05:52.785,0:05:56.222
utilizar ela como parte da padrão[br]e a partir de

0:05:56.222,0:05:58.825
então começar a executar os demais[br]comandos.

0:05:58.825,0:06:04.530
O comando copy serve justamente para[br]copiar arquivos para dentro do container.

0:06:04.597,0:06:09.102
Ele vai copiar todos os arquivos[br]da pasta que eu me encontro,

0:06:09.168,0:06:14.741
por isso o ponto para a pasta que eu[br]vou estar utilizando dentro do contêiner.

0:06:14.807,0:06:16.309
Por isso eu vou utilizar.

0:06:16.309,0:06:19.946
Ponto novamente[br]e aqui vai vir um ponto bem interessante.

0:06:20.012,0:06:25.051
A cópia do arquivo não é exatamente[br]uma boa prática, como a gente viu.

0:06:25.118,0:06:28.321
Se a gente não souber[br]utilizar o armazenamento de arquivos

0:06:28.321,0:06:32.692
de forma correta, isso vai atrapalhar[br]o bom funcionamento de um ponteiro.

0:06:32.925,0:06:37.530
A questão nesse caso é que,[br]como eu estou criando um container novo,

0:06:37.597,0:06:42.335
eu preciso passar a todos os códigos[br]que vão servir de base para ele.

0:06:42.402,0:06:47.073
Então eu posso copiar esses arquivos[br]sem a menor dor de cabeça,

0:06:47.140,0:06:50.610
já que eles vão passar[br]a ser parte fundamental

0:06:50.676,0:06:52.645
de todo o container que eu estou criando.

0:06:52.645,0:06:57.016
O passo seguinte,[br]então, é garantir que esse meu sistema

0:06:57.016,0:07:00.620
esteja utilizando o ambiente de produção.

0:07:00.720,0:07:03.456
Para isso,[br]eu posso executar um Warning Stall.

0:07:03.456,0:07:07.059
Esse comando é um comando[br]que pertence ao ambiente novo e serve

0:07:07.059,0:07:10.430
basicamente para instalar[br]todos os pacotes necessários

0:07:10.430,0:07:13.666
e preparar o ambiente para a execução[br]daquela minha aplicação.

0:07:13.766,0:07:17.437
Em seguida, eu vou utilizar o C MD,

0:07:17.503,0:07:20.206
que é basicamente uma forma de criar

0:07:20.206,0:07:23.042
linhas de comando dentro do container.

0:07:23.042,0:07:27.447
Nesse caso, eu estou chamando o comando[br]node e informando para ele

0:07:27.447,0:07:34.187
que o arquivo de origem da minha aplicação[br]está dentro da pasta SCR

0:07:34.287,0:07:35.021
index.

0:07:35.021,0:07:38.658
E esse é exatamente[br]o caminho que a gente checou agora a pouco

0:07:38.791,0:07:41.761
de onde estava o index da minha aplicação.

0:07:41.761,0:07:45.698
Então, a partir do momento que eu copiei[br]esses dados para dentro do container,

0:07:45.765,0:07:48.701
eu agora mostrei para o novo de[br]como executá lo.

0:07:48.701,0:07:52.872
Por fim, eu estou fazendo um ex[br]pouso da porta 3000.

0:07:53.105,0:07:56.108
Esse comando serve justamente[br]para eu informar

0:07:56.309,0:08:00.313
que eu vou ter que acessar[br]uma porta desse conta e dessa forma,

0:08:00.313,0:08:05.318
na hora que eu for criar o container para[br]colocá lo em execução, o Docker vai saber

0:08:05.318,0:08:10.189
que eu posso ter uma conexão de rede ali[br]e vai permitir a criação dessa interação.

0:08:10.289,0:08:15.228
Outro detalhe muito importante é que[br]eu tenho duas formas de executar comandos.

0:08:15.328,0:08:18.865
O primeiro é a partir do comando run.

0:08:18.931,0:08:22.001
O run vai simplesmente executar[br]aquela linha

0:08:22.001,0:08:25.004
de comando dentro do meu container.

0:08:25.004,0:08:28.741
Na hora que eu estiver fazendo[br]toda a parte de construção dele.

0:08:28.875,0:08:32.945
Enquanto isso, sem MD,[br]vão ser comandos que vão ser executados

0:08:33.012,0:08:35.515
posteriores à criação do meu container.

0:08:35.515,0:08:37.517
Dessa forma, quando eu crio lá o C.

0:08:37.517,0:08:41.420
MD chamando um comando novo[br]e passando o index,

0:08:41.521,0:08:46.692
toda vez que esse container for colocado[br]em execução, esse comando vai ser chamado.

0:08:46.759,0:08:49.762
Agora que todo esse processo[br]está finalizado,

0:08:49.996,0:08:52.698
eu posso utilizar esses arquivos

0:08:52.698,0:08:56.936
para construir o meu container,[br]utilizando então o prompt de comando.

0:08:57.003,0:09:01.307
Eu vou poder recorrer a uma função chamada

0:09:01.407,0:09:02.975
Docker build.

0:09:02.975,0:09:06.846
Esse comando é um comando bem simples[br]e não tem muita coisa que a gente deve

0:09:06.846,0:09:08.281
configurar nele.

0:09:08.281,0:09:12.785
Nesse caso, por exemplo,[br]a gente só vai nomear a imagem

0:09:12.852,0:09:16.722
e em seguida informar o endereço[br]do Dockerfile que vai ser utilizado.

0:09:16.789,0:09:20.459
Para isso[br]eu vou informar o menos ter seguido

0:09:20.459,0:09:23.462
do nome da imagem,

0:09:23.629,0:09:26.399
nesse caso vou chamar ela de Olá

0:09:26.399,0:09:29.268
e em seguida eu vou informar um ponto.

0:09:29.268,0:09:34.106
A função desse ponto[br]é para informar que eu já estou na pasta

0:09:34.173,0:09:37.710
aonde eu tenho o Dockerfile,[br]caso não esteja nessa pasta,

0:09:37.777,0:09:43.549
ao invés de informar o ponto eu vou ter[br]que informar todo o endereçamento de pasta

0:09:43.649,0:09:48.087
e esse endereçamento[br]vai variar entre sistemas operacionais.

0:09:48.154,0:09:51.857
A forma mais fácil[br]então é utilizar os comandos de navegação

0:09:51.857,0:09:56.329
de terminal como CD[br]para poder navegar pelos diretórios

0:09:56.429,0:09:59.365
e chegando no diretório[br]que tem o Dockerfile

0:09:59.365,0:10:03.803
ou simplesmente executar o Docker build[br]com o ponto no final.

0:10:03.903,0:10:06.772
Executando então o processo de build,

0:10:06.772,0:10:08.975
várias coisas vão ser executadas.

0:10:08.975,0:10:12.345
A primeira delas[br]é todo download de imagens,

0:10:12.445,0:10:15.748
seguido da construção das aplicações

0:10:15.815,0:10:19.552
e todo o teste de funcionamento[br]para ver se o comando inicial

0:10:19.552,0:10:21.253
vai ser executado com sucesso.

0:10:21.253,0:10:24.256
Caso você[br]possua alguma falha nesse processo,

0:10:24.423,0:10:27.893
você pode recorrer ao Docker Logs.

0:10:27.960,0:10:31.931
Esse é um comando que permite a gente[br]checar logo o ambiente Docker.

0:10:32.031,0:10:35.635
Inclusive é legal que você pode utilizar[br]ele para checar logs

0:10:35.635,0:10:40.506
individualmente de cada contêiner[br]com o processo de build concluído.

0:10:40.573,0:10:45.311
O Docker sempre vai perguntar se você não[br]quer fazer um scan de vulnerabilidades.

0:10:45.411,0:10:47.880
Nesse caso, não vai ser preciso.

0:10:47.880,0:10:50.082
A única coisa que nos falta agora

0:10:50.082,0:10:52.885
é colocar justamente[br]esse container em execução.

0:10:52.885,0:10:56.222
Para isso a gente vai recorrer ao comando[br]docker run.

0:10:56.288,0:11:00.259
Só que dessa vez eu vou ter que passar[br]alguns parâmetros de execução para ele.

0:11:00.459,0:11:03.396
O primeiro parâmetro vai ser justamente[br]para garantir

0:11:03.396,0:11:07.033
que essa imagem vai ficar em execução[br]o tempo todo.

0:11:07.133,0:11:09.769
Para isso, vou utilizar ao menos o D,

0:11:09.769,0:11:12.772
enquanto o segundo parâmetro menos p,

0:11:12.772,0:11:17.376
vai ser para informar o apontamento de[br]portas de rede.

0:11:17.443,0:11:20.046
Dessa forma,[br]todo o conteúdo da minha aplicação

0:11:20.046,0:11:23.449
vai ficar disponível[br]para acesso para executar então

0:11:23.549,0:11:28.921
o container que a gente acabou de criar,[br]eu vou fazer um Docker run

0:11:29.021,0:11:33.325
em menos de

0:11:33.392,0:11:36.395
menos P para informar a porta

0:11:36.429,0:11:39.765
e nesse caso eu expus a porta 3000.

0:11:39.865,0:11:44.236
Então vou utilizar 3002 pontos, 3000.

0:11:44.336,0:11:46.439
A razão de eu ter que repetir O31000

0:11:46.439,0:11:50.142
duas vezes[br]é porque eu estou falando de duas portas.

0:11:50.209,0:11:53.446
A primeira é a porta na minha máquina base

0:11:53.546,0:11:58.484
e a segunda é a porta do meu container,[br]que específico por exemplo,

0:11:58.484,0:12:02.188
a primeira porta,[br]que é a da máquina base, como 80.

0:12:02.254,0:12:04.790
Ela vai apontar um acesso

0:12:04.790,0:12:07.993
realizado na porta 80 do meu servidor base

0:12:08.094,0:12:12.131
para a porta 3000 do meu container.

0:12:12.198,0:12:15.201
Isso é algo que a gente tem que prestar[br]bastante atenção.

0:12:15.434,0:12:17.703
Às vezes,[br]quando a gente vai criar uma aplicação,

0:12:17.703,0:12:22.141
a gente tem vários containers[br]que tem expostas a porta 80

0:12:22.374,0:12:26.912
e eu posso apontar diversas portas[br]para dentro desses containers,

0:12:26.979,0:12:30.683
utilizando numerações diferentes[br]no meu rosto base.

0:12:30.783,0:12:37.123
O próximo passo então é informar o nome da[br]minha imagem, nesse caso o LA

0:12:37.189,0:12:39.091
colocando a imagem em execução

0:12:39.091,0:12:42.261
eu vou receber o código de validação dela

0:12:42.361,0:12:45.331
e se eu executar um Docker PRS?

0:12:45.364,0:12:49.068
Note que essa minha imagem[br]já se encontra em execução

0:12:49.168,0:12:53.372
e me informando que a porta 3000[br]está apontando para a porta

0:12:53.372,0:12:55.741
3000 do contêiner.

0:12:55.741,0:12:59.311
O último passo[br]então, é abrir o navegador web

0:12:59.378,0:13:03.983
e acessar[br]justamente a nossa máquina na porta 3000.

0:13:04.083,0:13:07.086
O IP que eu informei aqui 127,0

0:13:07.086,0:13:10.990
ponto zero[br]ponto um é o que se chama de local Rust.

0:13:11.056,0:13:13.759
Ele representa a própria máquina na rede.

0:13:13.759,0:13:19.732
Outra forma que você teria era escrever[br]por extenso local rows de 2,3000.

0:13:19.832,0:13:21.467
Qualquer uma das duas formas

0:13:21.467,0:13:25.304
já faria com que toda a interface[br]funcionasse normalmente.

0:13:25.404,0:13:28.407
No nosso caso, após acessar a aplicação,

0:13:28.507,0:13:33.245
todo o código que a gente criou e compilou[br]já está aqui disponível para uso

0:13:33.312,0:13:39.652
e eu consigo, por exemplo, ir adicionando[br]itens dentro dessa minha aplicação.

0:13:39.852,0:13:42.688
Esse é um exemplo de uma aplicação[br]bem simples,

0:13:42.688,0:13:47.293
só pra gente entender como é que eu começo[br]a construir todo esse ambiente.

0:13:47.359,0:13:50.596
A partir de agora,[br]você pode utilizar esses conhecimentos

0:13:50.696,0:13:54.200
para começar a renderizar[br]as suas próprias aplicações

0:13:54.300,0:13:58.304
e com isso entender um pouco mais[br]de como todo esse ecossistema funciona.