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:59.459
e um botãozinho, mas essa função
não tem nada programado,

00:00:59.459 --> 00:01:02.629
é realmente só para nós
termos um código para utilizar.

00:01:02.629 --> 00:01:06.599
Nesse caso, nós vamos
utilizar um código em Node

00:01:06.599 --> 00:01:11.538
e, justamente por isso, eu preciso utilizar,
como base para a minha imagem,

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

00:01:15.542 --> 00:01:18.344
Caso nós não achemos
uma imagem dessa forma,

00:01:18.344 --> 00:01:21.592
nós podemos passar comandos
dentro de um container

00:01:21.592 --> 00:01:25.985
para que ele faça todo o processo
de instalação daquele software

00:01:25.985 --> 00:01:29.589
e disponibilize todo aquele
ambiente montado para nós.

00:01:29.589 --> 00:01:34.327
Aqui dentro da minha tela, eu vou ter,
então, uma pasta chamada "app",

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

00:01:40.800 --> 00:01:46.773
O "yarn.lock", o "package",
a pasta "src" e a pasta "spec"

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

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

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

00:02:02.422 --> 00:02:06.292
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:12.843
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 nós temos
que nos atentar nele,

00:02:18.171 --> 00:02:23.287
a primeira delas é que esse
arquivo não tem extensão,

00:02:24.244 --> 00:02:27.740
a segunda é que ele sempre
vai começar com D maiúsculo

00:02:27.740 --> 00:02:31.017
e Dockerfile vai estar
escrito tudo junto.

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

00:02:34.621 --> 00:02:37.603
para que eu não impeça
o Docker de achar o arquivo

00:02:37.603 --> 00:02:40.293
e, assim, começar o processo
de build da imagem.

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

00:02:45.431 --> 00:02:49.769
Basta eu vir na aba de visualização
do Explorer no Windows

00:02:49.769 --> 00:02:56.209
e marcar a opção "file name extensions"
ou mostrar extensões de arquivo.

00:02:56.209 --> 00:03:00.213
Note que agora 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:07.292
Pode ser que quando você criou o arquivo
utilizando, por exemplo, o bloco de notas,

00:03:07.292 --> 00:03:11.991
ele tivesse mostrado
uma opção como txt.

00:03:11.991 --> 00:03:16.336
Caso ele tenha aparecido como txt
no final, basta apertar a tecla F2

00:03:16.336 --> 00:03:22.902
e renomear o arquivo excluindo ".txt"
e deixando apenas "dockerfile".

00:03:22.902 --> 00:03:27.224
O Windows vai pedir que você confirme
que aquele arquivo não vai ter uma extensão,

00:03:27.224 --> 00:03:30.944
basta confirmar e seguir
para as próximas etapas.

00:03:30.944 --> 00:03:34.380
Quando nós abrimos o Dockerfile
dentro de um bloco de notas,

00:03:34.380 --> 00:03:36.950
nós vamos ter uma estrutura
até bem simples.

00:03:36.950 --> 00:03:41.187
A primeira coisa que nós vamos
ver é justamente um comentário

00:03:41.187 --> 00:03:46.659
definindo qual tipo de sintaxe nós estamos
utilizando para construção desse arquivo.

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

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

00:03:54.701 --> 00:03:58.843
Por hora, você pode simplesmente copiar
essa linha para todos os seus arquivos

00:03:58.843 --> 00:04:02.609
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.252
algumas funções só vão estar disponíveis
em versões específicas do Dockerfile,

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

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

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

00:04:25.531 --> 00:04:31.371
Esse comando serve para eu especificar
qual imagem de base que eu vou utilizar.

00:04:31.371 --> 00:04:37.377
Nesse caso, uma imagem chamada
"node" na versão "12-alpine".

00:04:37.377 --> 00:04:42.497
É justamente aqui, por exemplo, que caso eu
queira criar um container totalmente do zero

00:04:42.497 --> 00:04:45.752
utilizando só um sistema
operacional de base,

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

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

00:04:53.192 --> 00:04:58.236
eu poderia fazer um FROM Ubuntu
e, nos comandos que se seguem,

00:04:58.236 --> 00:05:02.368
fazer todo o passo a passo
de instalação do Apache.

00:05:02.368 --> 00:05:08.350
Nesse caso, nós já estamos reaproveitando
parte da estrutura do Node que já está pronta

00:05:08.350 --> 00:05:11.411
e, aí, eu só preciso rodar
alguns poucos comandos

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

00:05:14.580 --> 00:05:19.093
Nosso próximo passo, então,
é rodar um "apk add"

00:05:19.093 --> 00:05:24.745
para garantir que eu tenho
um python2, o compilador C

00:05:24.745 --> 00:05:27.267
e o make dentro
da minha máquina.

00:05:27.927 --> 00:05:33.633
Nosso próximo passo, então, vai
ser criar um diretório de trabalho,

00:05:33.633 --> 00:05:36.002
nesse caso, chamado "app".

00:05:36.002 --> 00:05:40.406
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:49.382
Note que todo o nosso conteúdo do arquivo
está dentro de uma pasta chamada "app",

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

00:05:52.785 --> 00:05:55.129
utilizar ela como pasta padrão

00:05:55.129 --> 00:05:58.825
e, a partir de então, começar
a executar os demais comandos.

00:05:58.825 --> 00:06:04.597
O comando "COPY" serve justamente para eu
copiar arquivos para dentro do container.

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

00:06:09.168 --> 00:06:14.807
por isso o ponto, para a pasta que eu
estarei utilizando dentro do container,

00:06:14.807 --> 00:06:17.491
por isso, eu vou utilizar
"." novamente.

00:06:17.491 --> 00:06:20.012
E aqui vai vir um ponto
bem interessante:

00:06:20.012 --> 00:06:23.226
a cópia do arquivo não é
exatamente uma boa prática,

00:06:23.226 --> 00:06:29.298
como nós vimos, se nós não soubermos utilizar
o armazenamento de arquivos de forma correta,

00:06:29.298 --> 00:06:32.925
isso vai atrapalhar o bom
funcionamento de um container.

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

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

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

00:06:47.140 --> 00:06:50.676
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:54.247
O passo seguinte, então,

00:06:54.247 --> 00:07:00.720
é garantir que esse meu sistema esteja
utilizando um ambiente de produção.

00:07:00.720 --> 00:07:03.456
Para isso, eu posso
executar um "yarn install".

00:07:03.456 --> 00:07:06.656
Esse comando é um comando
que pertence ao ambiente Node

00:07:06.656 --> 00:07:10.430
e serve basicamente para instalar
todos os pacotes necessários

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

00:07:13.766 --> 00:07:17.503
Em seguida, eu vou
utilizar o "CMD",

00:07:17.503 --> 00:07:23.042
que é basicamente uma forma de criar
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:35.021
que o arquivo de origem da minha aplicação
está dentro da pasta "src/index".

00:07:35.021 --> 00:07:38.791
E esse é exatamente o caminho
que nós checamos agora há 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.765
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 Node
como executá-lo.

00:07:48.701 --> 00:07:53.105
Por fim, eu estou fazendo
um "EXPOSE" da porta 3000.

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

00:07:56.309 --> 00:07:59.297
que eu vou ter que acessar
uma porta desse container,

00:07:59.297 --> 00:08:03.586
dessa forma, na hora que eu for criar
o container para colocá-lo em execução,

00:08:03.586 --> 00:08:07.699
o Docker vai saber que eu posso
ter uma conexão de rede ali

00:08:07.699 --> 00:08:10.289
e vai permitir a criação
dessa interação.

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

00:08:15.328 --> 00:08:18.931
A primeira é a partir
do comando "run".

00:08:18.931 --> 00:08:25.004
O run vai simplesmente executar aquela
linha de comando dentro do meu container

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

00:08:28.875 --> 00:08:33.012
Enquanto isso, CMD vão ser
comandos que vão ser executados

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

00:08:35.515 --> 00:08:41.521
Dessa forma, quando eu crio lá o CMD chamando
um comando Node e passando o index,

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

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

00:08:49.996 --> 00:08:54.446
eu posso utilizar esses arquivos
para construir o meu container.

00:08:54.446 --> 00:09:00.674
Utilizando, então, o prompt de comando, 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:05.106
Esse comando é
um comando bem simples

00:09:05.106 --> 00:09:08.281
e não tem muita coisa que nós
temos que configurar nele.

00:09:08.281 --> 00:09:12.852
Nesse caso, por exemplo, nós
só vamos nomear a imagem

00:09:12.852 --> 00:09:16.789
e, em seguida, informar o endereço,
para o Dockerfile, que vai ser utilizado.

00:09:16.789 --> 00:09:21.904
Para isso, eu vou informar o "-t"
seguido do nome da imagem.

00:09:23.629 --> 00:09:29.268
Nesse caso, eu vou chamar ela de "ola"
e, em seguida, eu vou informar um ponto.

00:09:29.268 --> 00:09:35.509
A função desse ponto é informar que eu já
estou na pasta onde eu tenho o Dockerfile,

00:09:35.509 --> 00:09:39.230
caso eu não esteja nessa pasta,
ao invés de informar o ponto,

00:09:39.230 --> 00:09:43.649
eu vou ter que informar todo
o endereçamento de pasta

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

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

00:09:52.627 --> 00:09:56.429
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.903
simplesmente executar o "docker build"
com o ponto no final.

00:10:03.903 --> 00:10:08.975
Executando, então, o processo de build,
várias coisas vão ser executadas.

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

00:10:12.445 --> 00:10:17.964
seguido da construção das aplicações,
e todo o teste de funcionamento

00:10:17.964 --> 00:10:21.253
para ver se o comando inicial
vai ser executado com sucesso.

00:10:21.253 --> 00:10:27.960
Caso você possua alguma falha nesse processo,
você pode recorrer ao "docker logs".

00:10:27.960 --> 00:10:32.031
Esse é um comando que nos permite
checar logs no ambiente Docker.

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

00:10:36.559 --> 00:10:37.859
de cada container.

00:10:37.859 --> 00:10:40.573
Com o processo de build concluído,

00:10:40.573 --> 00:10:45.411
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:52.885
A única coisa que nos falta agora é colocar,
justamente, esse container em execução.

00:10:52.885 --> 00:10:56.288
Para isso, nós vamos recorrer
ao comando "docker run",

00:10:56.288 --> 00:11:00.459
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.133
que essa imagem vai ficar
em execução o tempo todo.

00:11:07.133 --> 00:11:09.769
Para isso, vou utilizar o "-d".

00:11:09.769 --> 00:11:17.443
Enquanto o segundo parâmetro, "-p", vai ser
para informar o apontamento de portas de rede,

00:11:17.443 --> 00:11:21.706
dessa forma, todo o conteúdo da minha
aplicação vai ficar disponível para acesso.

00:11:21.706 --> 00:11:25.496
Para executar, então, o container
que nós acabamos de criar,

00:11:25.496 --> 00:11:27.591
eu vou fazer um "docker run",

00:11:31.665 --> 00:11:32.615
"-d",

00:11:33.392 --> 00:11:36.429
"-p", para informar a porta,

00:11:36.429 --> 00:11:44.336
e, nesse caso, eu expus a porta 3000,
então eu vou utilizar "3000 : 3000".

00:11:44.336 --> 00:11:50.209
A razão de eu ter que repetir o 3000 duas vezes
é porque eu estou falando de duas portas.

00:11:50.209 --> 00:11:56.062
A primeira é a porta na minha máquina base
e a segunda é a porta do meu container,

00:11:56.062 --> 00:11:58.484
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.