WEBVTT

00:00:09.142 --> 00:00:13.279
Um dos passos mais importantes quando
nós falamos da utilização de Docker

00:00:13.279 --> 00:00:16.950
é justamente aprender a criar
o nosso próprio Docker,

00:00:16.950 --> 00:00:20.420
ou pelo menos a nossa
própria imagem.

00:00:20.420 --> 00:00:23.623
Para isso, nós vamos ter que utilizar
algumas ferramentas.

00:00:23.623 --> 00:00:29.896
A primeira e provavelmente mais importante
nesse processo vai ser o Dockerfile.

00:00:29.896 --> 00:00:34.925
Ele é basicamente um arquivo que vai permitir
que eu passe instruções para o Docker

00:00:34.925 --> 00:00:37.837
de como ele deve
construir aquela imagem.

00:00:37.837 --> 00:00:41.708
Antes de mais nada, eu vou precisar
pelo menos de algum código

00:00:41.708 --> 00:00:45.378
para que eu consiga colocar
em desenvolvimento.

00:00:45.378 --> 00:00:51.243
Para isso, eu peguei um códigozinho bem
simples de "hello, world" baseado em Node,

00:00:51.243 --> 00:00:55.388
é basicamente uma página que tem
um campinho de preenchimento de busca

00:00:55.388 --> 00:00:56.956
e um botãozinho.

00:00:56.956 --> 00:00:59.459
Mas essa função não tem nada programado.

00:00:59.459 --> 00:01:02.462
É realmente só pra a gente ter um código
para estar utilizando.

00:01:02.629 --> 00:01:06.499
Nesse caso a gente vai estar
utilizando um código em Node.

00:01:06.599 --> 00:01:11.471
E justamente por isso eu preciso utilizar
como base para a minha imagem

00:01:11.538 --> 00:01:15.442
uma imagem que já tenha um load
pronto para eu poder utilizar.

00:01:15.542 --> 00:01:18.344
Caso a gente
não ache uma imagem dessa forma,

00:01:18.344 --> 00:01:22.715
a gente pode passar comandos
dentro de um container para que ele faça

00:01:22.715 --> 00:01:25.919
todo o processo de instalação
daquele software

00:01:25.985 --> 00:01:29.522
e disponibilize
todo aquele ambiente montado para a gente.

00:01:29.589 --> 00:01:31.591
Aqui dentro da minha tela.

00:01:31.591 --> 00:01:34.327
Eu vou ter então uma pasta chamada EPP

00:01:34.327 --> 00:01:40.733
que eu criei dentro do meu desktop e nela
eu vou ter alguns arquivos

00:01:40.800 --> 00:01:43.703
o Yarn lock, o pack,

00:01:43.703 --> 00:01:46.706
a pasta CRC e a pasta espec.

00:01:46.773 --> 00:01:51.177
São justamente conteúdos que eu tenho
dessa minha aplicação.

00:01:51.244 --> 00:01:56.282
Se eu abro, por exemplo aqui o src,
eu vou ter um index ponto js

00:01:56.449 --> 00:02:02.322
que vai ser justamente
o arquivo inicial da minha aplicação.

00:02:02.422 --> 00:02:06.092
Aqui nessa pasta eu ainda tenho o arquivo
chamado Dockerfile.

00:02:06.292 --> 00:02:09.362
Esse é o arquivo que vai trazer
todas as instruções

00:02:09.362 --> 00:02:13.366
que o Docker precisa
para construir a nossa imagem.

00:02:13.466 --> 00:02:16.102
Existem algumas características
muito importantes

00:02:16.102 --> 00:02:18.171
que a gente tem que se atentar nele.

00:02:18.171 --> 00:02:20.740
A primeira delas é que esse arquivo

00:02:20.740 --> 00:02:24.177
não tem extensão.

00:02:24.244 --> 00:02:26.446
A segunda é que ele sempre vai começar

00:02:26.446 --> 00:02:30.917
com D maiúsculo e Doc
e vai estar escrito tudo junto.

00:02:31.017 --> 00:02:34.521
Eu preciso justamente prestar atenção
em todos esses padrões

00:02:34.621 --> 00:02:36.289
para que eu não impeça o Docker

00:02:36.289 --> 00:02:40.193
de achar o arquivo e assim começar
o processo de build da imagem.

00:02:40.293 --> 00:02:45.365
Agora como que eu valido
isso aqui dentro dos meus arquivos?

00:02:45.431 --> 00:02:49.669
Basta ouvir na aba de visualização
do Explorer no Windows

00:02:49.769 --> 00:02:51.971
e marcar a opção Fill

00:02:51.971 --> 00:02:56.142
Extensions
ou mostrar extensões de arquivo.

00:02:56.209 --> 00:02:57.143
Note que agora

00:02:57.143 --> 00:03:00.146
todos os meus arquivos
ganharam uma extensão.

00:03:00.213 --> 00:03:02.348
Menos no Dockerfile.

00:03:02.348 --> 00:03:06.252
Pode ser que quando você tenha criado
o arquivo utilizando, por exemplo,

00:03:06.252 --> 00:03:11.791
o bloco de notas,
ele tivesse mostrado uma opção como txt.

00:03:11.991 --> 00:03:13.927
Caso ele tenha aparecido como txt.

00:03:13.927 --> 00:03:18.231
No final, basta apertar a tecla F2
e renomear o arquivo

00:03:18.331 --> 00:03:22.835
excluindo o ponto txt
e deixando apenas Dockerfile.

00:03:22.902 --> 00:03:25.972
O Windows vai pedir que você confirme
que aquele arquivo

00:03:25.972 --> 00:03:30.877
não vai ter uma extensão, basta confirmar
e seguir para as próximas etapas.

00:03:30.944 --> 00:03:34.380
Quando a gente abre o Dockerfile
dentro de um bloco de notas,

00:03:34.380 --> 00:03:36.950
a gente vai ter uma estrutura
até bem simples.

00:03:36.950 --> 00:03:41.187
A primeira coisa que a gente vai ver
é justamente um comentário

00:03:41.187 --> 00:03:45.425
definindo o qual tipo de sintaxe
a gente está utilizando para construção

00:03:45.425 --> 00:03:46.659
desse arquivo.

00:03:46.659 --> 00:03:49.562
Nesse caso, uma sintaxe de versão um.

00:03:49.562 --> 00:03:54.634
As linhas de comando que definem a sintaxe
estão lá na documentação do Docker.

00:03:54.701 --> 00:03:57.403
Por hora,
você pode simplesmente copiar essa linha

00:03:57.403 --> 00:04:02.508
para todos os seus arquivos
e tudo vai correr sem maiores problemas.

00:04:02.609 --> 00:04:06.179
Agora, caso você se torne
um usuário avançado de Docker,

00:04:06.179 --> 00:04:12.185
algumas funções só vão estar disponíveis
em versões específicas do Docker File,

00:04:12.252 --> 00:04:17.023
então você vai ter que ficar atento
a qual tipo de Docker vai utilizar

00:04:17.090 --> 00:04:21.461
para poder criar exatamente o container
da forma que você precisa.

00:04:21.561 --> 00:04:25.465
Logo em seguida
eu tenho um comando chamado FROM.

00:04:25.531 --> 00:04:28.268
Esse comando serve para eu especificar

00:04:28.268 --> 00:04:31.271
qual a imagem de base
que eu vou estar utilizando.

00:04:31.371 --> 00:04:34.574
Nesse caso, uma imagem chamada Node

00:04:34.674 --> 00:04:37.377
na versão 12 ao painel.

00:04:37.377 --> 00:04:41.047
É justamente aqui, por exemplo,
que caso queira criar um container

00:04:41.147 --> 00:04:45.685
totalmente do zero, utilizando
só um sistema operacional de base,

00:04:45.752 --> 00:04:49.389
eu vou conseguir especificar que eu quero
esse sistema operacional.

00:04:49.622 --> 00:04:53.092
Se eu quisesse, por exemplo,
criar um servidor Apache do zero,

00:04:53.192 --> 00:04:57.397
eu poderia fazer um from Ubuntu
e nos comandos

00:04:57.397 --> 00:05:02.268
que se seguem fazer todo o passo
a passo de instalação do Apache.

00:05:02.368 --> 00:05:06.839
Nesse caso, a gente já está reaproveitando
parte da estrutura do Node

00:05:06.906 --> 00:05:11.411
que já está pronta e aí
eu só preciso rodar alguns poucos comandos

00:05:11.411 --> 00:05:14.414
e copiar os meus arquivos
para dentro do container.

00:05:14.580 --> 00:05:18.551
Nosso próximo passo então é rodar a PK

00:05:18.551 --> 00:05:23.122
Red pra
garantir aí que eu tenho um Python dois,

00:05:23.222 --> 00:05:27.827
o compilador C e o
make dentro da minha máquina.

00:05:27.927 --> 00:05:30.029
Nosso próximo passo então

00:05:30.029 --> 00:05:33.566
vai ser criar um diretório de trabalho,

00:05:33.633 --> 00:05:36.002
nesse caso chamado EPP.

00:05:36.002 --> 00:05:40.306
Esse diretório de trabalho
vai basicamente informar para o container

00:05:40.406 --> 00:05:43.409
qual pasta
ele deve utilizar para poder trabalhar.

00:05:43.409 --> 00:05:46.412
Note que todo nosso conteúdo do arquivo

00:05:46.479 --> 00:05:49.382
está dentro de uma pasta chamada EPP.

00:05:49.382 --> 00:05:52.785
Dessa forma eu vou conseguir navegar
para dentro dessa pasta,

00:05:52.785 --> 00:05:56.222
utilizar ela como parte da padrão
e a partir de

00:05:56.222 --> 00:05:58.825
então começar a executar os demais
comandos.

00:05:58.825 --> 00:06:04.530
O comando copy serve justamente para
copiar arquivos para dentro do container.

00:06:04.597 --> 00:06:09.102
Ele vai copiar todos os arquivos
da pasta que eu me encontro,

00:06:09.168 --> 00:06:14.741
por isso o ponto para a pasta que eu
vou estar utilizando dentro do contêiner.

00:06:14.807 --> 00:06:16.309
Por isso eu vou utilizar.

00:06:16.309 --> 00:06:19.946
Ponto novamente
e aqui vai vir um ponto bem interessante.

00:06:20.012 --> 00:06:25.051
A cópia do arquivo não é exatamente
uma boa prática, como a gente viu.

00:06:25.118 --> 00:06:28.321
Se a gente não souber
utilizar o armazenamento de arquivos

00:06:28.321 --> 00:06:32.692
de forma correta, isso vai atrapalhar
o bom funcionamento de um ponteiro.

00:06:32.925 --> 00:06:37.530
A questão nesse caso é que,
como eu estou criando um container novo,

00:06:37.597 --> 00:06:42.335
eu preciso passar a todos os códigos
que vão servir de base para ele.

00:06:42.402 --> 00:06:47.073
Então eu posso copiar esses arquivos
sem a menor dor de cabeça,

00:06:47.140 --> 00:06:50.610
já que eles vão passar
a ser parte fundamental

00:06:50.676 --> 00:06:52.645
de todo o container que eu estou criando.

00:06:52.645 --> 00:06:57.016
O passo seguinte,
então, é garantir que esse meu sistema

00:06:57.016 --> 00:07:00.620
esteja utilizando o ambiente de produção.

00:07:00.720 --> 00:07:03.456
Para isso,
eu posso executar um Warning Stall.

00:07:03.456 --> 00:07:07.059
Esse comando é um comando
que pertence ao ambiente novo e serve

00:07:07.059 --> 00:07:10.430
basicamente para instalar
todos os pacotes necessários

00:07:10.430 --> 00:07:13.666
e preparar o ambiente para a execução
daquela minha aplicação.

00:07:13.766 --> 00:07:17.437
Em seguida, eu vou utilizar o C MD,

00:07:17.503 --> 00:07:20.206
que é basicamente uma forma de criar

00:07:20.206 --> 00:07:23.042
linhas de comando dentro do container.

00:07:23.042 --> 00:07:27.447
Nesse caso, eu estou chamando o comando
node e informando para ele

00:07:27.447 --> 00:07:34.187
que o arquivo de origem da minha aplicação
está dentro da pasta SCR

00:07:34.287 --> 00:07:35.021
index.

00:07:35.021 --> 00:07:38.658
E esse é exatamente
o caminho que a gente checou agora a pouco

00:07:38.791 --> 00:07:41.761
de onde estava o index da minha aplicação.

00:07:41.761 --> 00:07:45.698
Então, a partir do momento que eu copiei
esses dados para dentro do container,

00:07:45.765 --> 00:07:48.701
eu agora mostrei para o novo de
como executá lo.

00:07:48.701 --> 00:07:52.872
Por fim, eu estou fazendo um ex
pouso da porta 3000.

00:07:53.105 --> 00:07:56.108
Esse comando serve justamente
para eu informar

00:07:56.309 --> 00:08:00.313
que eu vou ter que acessar
uma porta desse conta e dessa forma,

00:08:00.313 --> 00:08:05.318
na hora que eu for criar o container para
colocá lo em execução, o Docker vai saber

00:08:05.318 --> 00:08:10.189
que eu posso ter uma conexão de rede ali
e vai permitir a criação dessa interação.

00:08:10.289 --> 00:08:15.228
Outro detalhe muito importante é que
eu tenho duas formas de executar comandos.

00:08:15.328 --> 00:08:18.865
O primeiro é a partir do comando run.

00:08:18.931 --> 00:08:22.001
O run vai simplesmente executar
aquela linha

00:08:22.001 --> 00:08:25.004
de comando dentro do meu container.

00:08:25.004 --> 00:08:28.741
Na hora que eu estiver fazendo
toda a parte de construção dele.

00:08:28.875 --> 00:08:32.945
Enquanto isso, sem MD,
vão ser comandos que vão ser executados

00:08:33.012 --> 00:08:35.515
posteriores à criação do meu container.

00:08:35.515 --> 00:08:37.517
Dessa forma, quando eu crio lá o C.

00:08:37.517 --> 00:08:41.420
MD chamando um comando novo
e passando o index,

00:08:41.521 --> 00:08:46.692
toda vez que esse container for colocado
em execução, esse comando vai ser chamado.

00:08:46.759 --> 00:08:49.762
Agora que todo esse processo
está finalizado,

00:08:49.996 --> 00:08:52.698
eu posso utilizar esses arquivos

00:08:52.698 --> 00:08:56.936
para construir o meu container,
utilizando então o prompt de comando.

00:08:57.003 --> 00:09:01.307
Eu vou poder recorrer a uma função chamada

00:09:01.407 --> 00:09:02.975
Docker build.

00:09:02.975 --> 00:09:06.846
Esse comando é um comando bem simples
e não tem muita coisa que a gente deve

00:09:06.846 --> 00:09:08.281
configurar nele.

00:09:08.281 --> 00:09:12.785
Nesse caso, por exemplo,
a gente só vai nomear a imagem

00:09:12.852 --> 00:09:16.722
e em seguida informar o endereço
do Dockerfile que vai ser utilizado.

00:09:16.789 --> 00:09:20.459
Para isso
eu vou informar o menos ter seguido

00:09:20.459 --> 00:09:23.462
do nome da imagem,

00:09:23.629 --> 00:09:26.399
nesse caso vou chamar ela de Olá

00:09:26.399 --> 00:09:29.268
e em seguida eu vou informar um ponto.

00:09:29.268 --> 00:09:34.106
A função desse ponto
é para informar que eu já estou na pasta

00:09:34.173 --> 00:09:37.710
aonde eu tenho o Dockerfile,
caso não esteja nessa pasta,

00:09:37.777 --> 00:09:43.549
ao invés de informar o ponto eu vou ter
que informar todo o endereçamento de pasta

00:09:43.649 --> 00:09:48.087
e esse endereçamento
vai variar entre sistemas operacionais.

00:09:48.154 --> 00:09:51.857
A forma mais fácil
então é utilizar os comandos de navegação

00:09:51.857 --> 00:09:56.329
de terminal como CD
para poder navegar pelos diretórios

00:09:56.429 --> 00:09:59.365
e chegando no diretório
que tem o Dockerfile

00:09:59.365 --> 00:10:03.803
ou simplesmente executar o Docker build
com o ponto no final.

00:10:03.903 --> 00:10:06.772
Executando então o processo de build,

00:10:06.772 --> 00:10:08.975
várias coisas vão ser executadas.

00:10:08.975 --> 00:10:12.345
A primeira delas
é todo download de imagens,

00:10:12.445 --> 00:10:15.748
seguido da construção das aplicações

00:10:15.815 --> 00:10:19.552
e todo o teste de funcionamento
para ver se o comando inicial

00:10:19.552 --> 00:10:21.253
vai ser executado com sucesso.

00:10:21.253 --> 00:10:24.256
Caso você
possua alguma falha nesse processo,

00:10:24.423 --> 00:10:27.893
você pode recorrer ao Docker Logs.

00:10:27.960 --> 00:10:31.931
Esse é um comando que permite a gente
checar logo o ambiente Docker.

00:10:32.031 --> 00:10:35.635
Inclusive é legal que você pode utilizar
ele para checar logs

00:10:35.635 --> 00:10:40.506
individualmente de cada contêiner
com o processo de build concluído.

00:10:40.573 --> 00:10:45.311
O Docker sempre vai perguntar se você não
quer fazer um scan de vulnerabilidades.

00:10:45.411 --> 00:10:47.880
Nesse caso, não vai ser preciso.

00:10:47.880 --> 00:10:50.082
A única coisa que nos falta agora

00:10:50.082 --> 00:10:52.885
é colocar justamente
esse container em execução.

00:10:52.885 --> 00:10:56.222
Para isso a gente vai recorrer ao comando
docker run.

00:10:56.288 --> 00:11:00.259
Só que dessa vez eu vou ter que passar
alguns parâmetros de execução para ele.

00:11:00.459 --> 00:11:03.396
O primeiro parâmetro vai ser justamente
para garantir

00:11:03.396 --> 00:11:07.033
que essa imagem vai ficar em execução
o tempo todo.

00:11:07.133 --> 00:11:09.769
Para isso, vou utilizar ao menos o D,

00:11:09.769 --> 00:11:12.772
enquanto o segundo parâmetro menos p,

00:11:12.772 --> 00:11:17.376
vai ser para informar o apontamento de
portas de rede.

00:11:17.443 --> 00:11:20.046
Dessa forma,
todo o conteúdo da minha aplicação

00:11:20.046 --> 00:11:23.449
vai ficar disponível
para acesso para executar então

00:11:23.549 --> 00:11:28.921
o container que a gente acabou de criar,
eu vou fazer um Docker run

00:11:29.021 --> 00:11:33.325
em menos de

00:11:33.392 --> 00:11:36.395
menos P para informar a porta

00:11:36.429 --> 00:11:39.765
e nesse caso eu expus a porta 3000.

00:11:39.865 --> 00:11:44.236
Então vou utilizar 3002 pontos, 3000.

00:11:44.336 --> 00:11:46.439
A razão de eu ter que repetir O31000

00:11:46.439 --> 00:11:50.142
duas vezes
é porque eu estou falando de duas portas.

00:11:50.209 --> 00:11:53.446
A primeira é a porta na minha máquina base

00:11:53.546 --> 00:11:58.484
e a segunda é a porta do meu container,
que específico por exemplo,

00:11:58.484 --> 00:12:02.188
a primeira porta,
que é a da máquina base, como 80.

00:12:02.254 --> 00:12:04.790
Ela vai apontar um acesso

00:12:04.790 --> 00:12:07.993
realizado na porta 80 do meu servidor base

00:12:08.094 --> 00:12:12.131
para a porta 3000 do meu container.

00:12:12.198 --> 00:12:15.201
Isso é algo que a gente tem que prestar
bastante atenção.

00:12:15.434 --> 00:12:17.703
Às vezes,
quando a gente vai criar uma aplicação,

00:12:17.703 --> 00:12:22.141
a gente tem vários containers
que tem expostas a porta 80

00:12:22.374 --> 00:12:26.912
e eu posso apontar diversas portas
para dentro desses containers,

00:12:26.979 --> 00:12:30.683
utilizando numerações diferentes
no meu rosto base.

00:12:30.783 --> 00:12:37.123
O próximo passo então é informar o nome da
minha imagem, nesse caso o LA

00:12:37.189 --> 00:12:39.091
colocando a imagem em execução

00:12:39.091 --> 00:12:42.261
eu vou receber o código de validação dela

00:12:42.361 --> 00:12:45.331
e se eu executar um Docker PRS?

00:12:45.364 --> 00:12:49.068
Note que essa minha imagem
já se encontra em execução

00:12:49.168 --> 00:12:53.372
e me informando que a porta 3000
está apontando para a porta

00:12:53.372 --> 00:12:55.741
3000 do contêiner.

00:12:55.741 --> 00:12:59.311
O último passo
então, é abrir o navegador web

00:12:59.378 --> 00:13:03.983
e acessar
justamente a nossa máquina na porta 3000.

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

00:13:07.086 --> 00:13:10.990
ponto zero
ponto um é o que se chama de local Rust.

00:13:11.056 --> 00:13:13.759
Ele representa a própria máquina na rede.

00:13:13.759 --> 00:13:19.732
Outra forma que você teria era escrever
por extenso local rows de 2,3000.

00:13:19.832 --> 00:13:21.467
Qualquer uma das duas formas

00:13:21.467 --> 00:13:25.304
já faria com que toda a interface
funcionasse normalmente.

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

00:13:28.507 --> 00:13:33.245
todo o código que a gente criou e compilou
já está aqui disponível para uso

00:13:33.312 --> 00:13:39.652
e eu consigo, por exemplo, ir adicionando
itens dentro dessa minha aplicação.

00:13:39.852 --> 00:13:42.688
Esse é um exemplo de uma aplicação
bem simples,

00:13:42.688 --> 00:13:47.293
só pra gente entender como é que eu começo
a construir todo esse ambiente.

00:13:47.359 --> 00:13:50.596
A partir de agora,
você pode utilizar esses conhecimentos

00:13:50.696 --> 00:13:54.200
para começar a renderizar
as suas próprias aplicações

00:13:54.300 --> 00:13:58.304
e com isso entender um pouco mais
de como todo esse ecossistema funciona.