0:00:09.142,0:00:13.279
Um dos passos mais importantes quando[br]nós falamos da utilização de Docker

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

0:00:16.950,0:00:20.420
ou pelo menos a nossa[br]própria imagem.

0:00:20.420,0:00:23.623
Para isso, nós vamos ter que utilizar[br]algumas ferramentas.

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

0:00:29.896,0:00:34.925
Ele é basicamente um arquivo que vai permitir[br]que eu passe instruções para o Docker

0:00:34.925,0:00:37.837
de como ele deve[br]construir aquela imagem.

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

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

0:00:45.378,0:00:51.243
Para isso, eu peguei um códigozinho bem[br]simples de "hello, world" baseado em Node,

0:00:51.243,0:00:55.388
é basicamente uma página que tem[br]um campinho de preenchimento de busca

0:00:55.388,0:00:59.459
e um botãozinho, mas essa função[br]não tem nada programado,

0:00:59.459,0:01:02.629
é realmente só para nós[br]termos um código para utilizar.

0:01:02.629,0:01:06.599
Nesse caso, nós vamos[br]utilizar um código em Node

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

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

0:01:15.542,0:01:18.344
Caso nós não achemos[br]uma imagem dessa forma,

0:01:18.344,0:01:21.592
nós podemos passar comandos[br]dentro de um container

0:01:21.592,0:01:25.985
para que ele faça todo o processo[br]de instalação daquele software

0:01:25.985,0:01:29.589
e disponibilize todo aquele[br]ambiente montado para nós.

0:01:29.589,0:01:34.327
Aqui dentro da minha tela, eu vou ter,[br]então, uma pasta chamada "app",

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

0:01:40.800,0:01:46.773
O "yarn.lock", o "package",[br]a pasta "src" e a pasta "spec"

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

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

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

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

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

0:02:09.362,0:02:12.843
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 nós temos[br]que nos atentar nele,

0:02:18.171,0:02:23.287
a primeira delas é que esse[br]arquivo não tem extensão,

0:02:24.244,0:02:27.740
a segunda é que ele sempre[br]vai começar com D maiúsculo

0:02:27.740,0:02:31.017
e Dockerfile vai estar[br]escrito tudo junto.

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

0:02:34.621,0:02:37.603
para que eu não impeça[br]o Docker de achar o arquivo

0:02:37.603,0:02:40.293
e, assim, começar o processo[br]de build da imagem.

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

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

0:02:49.769,0:02:56.209
e marcar a opção "file name extensions"[br]ou mostrar extensões de arquivo.

0:02:56.209,0:03:00.213
Note que agora todos os meus[br]arquivos ganharam uma extensão,

0:03:00.213,0:03:02.348
menos no dockerfile.

0:03:02.348,0:03:07.292
Pode ser que quando você criou o arquivo[br]utilizando, por exemplo, o bloco de notas,

0:03:07.292,0:03:11.991
ele tivesse mostrado[br]uma opção como txt.

0:03:11.991,0:03:16.336
Caso ele tenha aparecido como txt[br]no final, basta apertar a tecla F2

0:03:16.336,0:03:22.902
e renomear o arquivo excluindo ".txt"[br]e deixando apenas "dockerfile".

0:03:22.902,0:03:27.224
O Windows vai pedir que você confirme[br]que aquele arquivo não vai ter uma extensão,

0:03:27.224,0:03:30.944
basta confirmar e seguir[br]para as próximas etapas.

0:03:30.944,0:03:34.380
Quando nós abrimos o Dockerfile[br]dentro de um bloco de notas,

0:03:34.380,0:03:36.950
nós vamos ter uma estrutura[br]até bem simples.

0:03:36.950,0:03:41.187
A primeira coisa que nós vamos[br]ver é justamente um comentário

0:03:41.187,0:03:46.659
definindo qual tipo de sintaxe nós estamos[br]utilizando para construção desse arquivo.

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

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

0:03:54.701,0:03:58.843
Por hora, você pode simplesmente copiar[br]essa linha para todos os seus arquivos

0:03:58.843,0:04:02.609
e tudo vai correr sem[br]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.252
algumas funções só vão estar disponíveis[br]em versões específicas do Dockerfile,

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

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

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

0:04:25.531,0:04:31.371
Esse comando serve para eu especificar[br]qual imagem de base que eu vou utilizar.

0:04:31.371,0:04:37.377
Nesse caso, uma imagem chamada[br]"node" na versão "12-alpine".

0:04:37.377,0:04:42.497
É justamente aqui, por exemplo, que caso eu[br]queira criar um container totalmente do zero

0:04:42.497,0:04:45.752
utilizando só um sistema[br]operacional de base,

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

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

0:04:53.192,0:04:58.236
eu poderia fazer um FROM Ubuntu[br]e, nos comandos que se seguem,

0:04:58.236,0:05:02.368
fazer todo o passo a passo[br]de instalação do Apache.

0:05:02.368,0:05:08.350
Nesse caso, nós já estamos reaproveitando[br]parte da estrutura do Node que já está pronta

0:05:08.350,0:05:11.411
e, aí, eu só preciso rodar[br]alguns poucos comandos

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

0:05:14.580,0:05:19.093
Nosso próximo passo, então,[br]é rodar um "apk add"

0:05:19.093,0:05:24.745
para garantir que eu tenho[br]um python2, o compilador C

0:05:24.745,0:05:27.267
e o make dentro[br]da minha máquina.

0:05:27.927,0:05:33.633
Nosso próximo passo, então, vai[br]ser criar um diretório de trabalho,

0:05:33.633,0:05:36.002
nesse caso, chamado "app".

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

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

0:05:43.409,0:05:49.382
Note que todo o nosso conteúdo do arquivo[br]está dentro de uma pasta chamada "app",

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

0:05:52.785,0:05:55.129
utilizar ela como pasta padrão

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

0:05:58.825,0:06:04.597
O comando "COPY" serve justamente para eu[br]copiar arquivos para dentro do container.

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

0:06:09.168,0:06:14.807
por isso o ponto, para a pasta que eu[br]estarei utilizando dentro do container.

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.