1
00:00:09,142 --> 00:00:10,710
Um dos passos mais importantes

2
00:00:10,710 --> 00:00:13,279
quando a gente fala
da utilização de Docker

3
00:00:13,279 --> 00:00:16,850
é justamente aprender
a criar o nosso próprio Docker,

4
00:00:16,950 --> 00:00:20,320
ou pelo menos a nossa própria imagem.

5
00:00:20,420 --> 00:00:23,423
Para isso, a gente vai ter que utilizar
algumas ferramentas.

6
00:00:23,623 --> 00:00:29,829
A primeira e provavelmente mais importante
nesse processo vai ser o Dockerfile.

7
00:00:29,896 --> 00:00:33,400
Ele é basicamente um arquivo
que vai permitir que eu passe

8
00:00:33,400 --> 00:00:37,771
instruções para o Docker
de como ele deve construir aquela imagem.

9
00:00:37,837 --> 00:00:41,708
Antes de mais nada,
eu vou precisar pelo menos de algum código

10
00:00:41,708 --> 00:00:45,311
para que eu consiga colocar
em desenvolvimento.

11
00:00:45,378 --> 00:00:49,349
Para isso eu peguei um código zinho
bem simples de resolver,

12
00:00:49,549 --> 00:00:53,186
baseado aí em onde é
basicamente uma página que tem

13
00:00:53,186 --> 00:00:56,890
um campinho de preenchimento de busca
e um botãozinho.

14
00:00:56,956 --> 00:00:59,459
Mas essa função não tem nada programado.

15
00:00:59,459 --> 00:01:02,462
É realmente só pra a gente ter um código
para estar utilizando.

16
00:01:02,629 --> 00:01:06,499
Nesse caso a gente vai estar
utilizando um código em Node.

17
00:01:06,599 --> 00:01:11,471
E justamente por isso eu preciso utilizar
como base para a minha imagem

18
00:01:11,538 --> 00:01:15,442
uma imagem que já tenha um load
pronto para eu poder utilizar.

19
00:01:15,542 --> 00:01:18,344
Caso a gente
não ache uma imagem dessa forma,

20
00:01:18,344 --> 00:01:22,715
a gente pode passar comandos
dentro de um container para que ele faça

21
00:01:22,715 --> 00:01:25,919
todo o processo de instalação
daquele software

22
00:01:25,985 --> 00:01:29,522
e disponibilize
todo aquele ambiente montado para a gente.

23
00:01:29,589 --> 00:01:31,591
Aqui dentro da minha tela.

24
00:01:31,591 --> 00:01:34,327
Eu vou ter então uma pasta chamada EPP

25
00:01:34,327 --> 00:01:40,733
que eu criei dentro do meu desktop e nela
eu vou ter alguns arquivos

26
00:01:40,800 --> 00:01:43,703
o Yarn lock, o pack,

27
00:01:43,703 --> 00:01:46,706
a pasta CRC e a pasta espec.

28
00:01:46,773 --> 00:01:51,177
São justamente conteúdos que eu tenho
dessa minha aplicação.

29
00:01:51,244 --> 00:01:56,282
Se eu abro, por exemplo aqui o src,
eu vou ter um index ponto js

30
00:01:56,449 --> 00:02:02,322
que vai ser justamente
o arquivo inicial da minha aplicação.

31
00:02:02,422 --> 00:02:06,092
Aqui nessa pasta eu ainda tenho o arquivo
chamado Dockerfile.

32
00:02:06,292 --> 00:02:09,362
Esse é o arquivo que vai trazer
todas as instruções

33
00:02:09,362 --> 00:02:13,366
que o Docker precisa
para construir a nossa imagem.

34
00:02:13,466 --> 00:02:16,102
Existem algumas características
muito importantes

35
00:02:16,102 --> 00:02:18,171
que a gente tem que se atentar nele.

36
00:02:18,171 --> 00:02:20,740
A primeira delas é que esse arquivo

37
00:02:20,740 --> 00:02:24,177
não tem extensão.

38
00:02:24,244 --> 00:02:26,446
A segunda é que ele sempre vai começar

39
00:02:26,446 --> 00:02:30,917
com D maiúsculo e Doc
e vai estar escrito tudo junto.

40
00:02:31,017 --> 00:02:34,521
Eu preciso justamente prestar atenção
em todos esses padrões

41
00:02:34,621 --> 00:02:36,289
para que eu não impeça o Docker

42
00:02:36,289 --> 00:02:40,193
de achar o arquivo e assim começar
o processo de build da imagem.

43
00:02:40,293 --> 00:02:45,365
Agora como que eu valido
isso aqui dentro dos meus arquivos?

44
00:02:45,431 --> 00:02:49,669
Basta ouvir na aba de visualização
do Explorer no Windows

45
00:02:49,769 --> 00:02:51,971
e marcar a opção Fill

46
00:02:51,971 --> 00:02:56,142
Extensions
ou mostrar extensões de arquivo.

47
00:02:56,209 --> 00:02:57,143
Note que agora

48
00:02:57,143 --> 00:03:00,146
todos os meus arquivos
ganharam uma extensão.

49
00:03:00,213 --> 00:03:02,348
Menos no Dockerfile.

50
00:03:02,348 --> 00:03:06,252
Pode ser que quando você tenha criado
o arquivo utilizando, por exemplo,

51
00:03:06,252 --> 00:03:11,791
o bloco de notas,
ele tivesse mostrado uma opção como txt.

52
00:03:11,991 --> 00:03:13,927
Caso ele tenha aparecido como txt.

53
00:03:13,927 --> 00:03:18,231
No final, basta apertar a tecla F2
e renomear o arquivo

54
00:03:18,331 --> 00:03:22,835
excluindo o ponto txt
e deixando apenas Dockerfile.

55
00:03:22,902 --> 00:03:25,972
O Windows vai pedir que você confirme
que aquele arquivo

56
00:03:25,972 --> 00:03:30,877
não vai ter uma extensão, basta confirmar
e seguir para as próximas etapas.

57
00:03:30,944 --> 00:03:34,380
Quando a gente abre o Dockerfile
dentro de um bloco de notas,

58
00:03:34,380 --> 00:03:36,950
a gente vai ter uma estrutura
até bem simples.

59
00:03:36,950 --> 00:03:41,187
A primeira coisa que a gente vai ver
é justamente um comentário

60
00:03:41,187 --> 00:03:45,425
definindo o qual tipo de sintaxe
a gente está utilizando para construção

61
00:03:45,425 --> 00:03:46,659
desse arquivo.

62
00:03:46,659 --> 00:03:49,562
Nesse caso, uma sintaxe de versão um.

63
00:03:49,562 --> 00:03:54,634
As linhas de comando que definem a sintaxe
estão lá na documentação do Docker.

64
00:03:54,701 --> 00:03:57,403
Por hora,
você pode simplesmente copiar essa linha

65
00:03:57,403 --> 00:04:02,508
para todos os seus arquivos
e tudo vai correr sem maiores problemas.

66
00:04:02,609 --> 00:04:06,179
Agora, caso você se torne
um usuário avançado de Docker,

67
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,

68
00:04:12,252 --> 00:04:17,023
então você vai ter que ficar atento
a qual tipo de Docker vai utilizar

69
00:04:17,090 --> 00:04:21,461
para poder criar exatamente o container
da forma que você precisa.

70
00:04:21,561 --> 00:04:25,465
Logo em seguida
eu tenho um comando chamado FROM.

71
00:04:25,531 --> 00:04:28,268
Esse comando serve para eu especificar

72
00:04:28,268 --> 00:04:31,271
qual a imagem de base
que eu vou estar utilizando.

73
00:04:31,371 --> 00:04:34,574
Nesse caso, uma imagem chamada Node

74
00:04:34,674 --> 00:04:37,377
na versão 12 ao painel.

75
00:04:37,377 --> 00:04:41,047
É justamente aqui, por exemplo,
que caso queira criar um container

76
00:04:41,147 --> 00:04:45,685
totalmente do zero, utilizando
só um sistema operacional de base,

77
00:04:45,752 --> 00:04:49,389
eu vou conseguir especificar que eu quero
esse sistema operacional.

78
00:04:49,622 --> 00:04:53,092
Se eu quisesse, por exemplo,
criar um servidor Apache do zero,

79
00:04:53,192 --> 00:04:57,397
eu poderia fazer um from Ubuntu
e nos comandos

80
00:04:57,397 --> 00:05:02,268
que se seguem fazer todo o passo
a passo de instalação do Apache.

81
00:05:02,368 --> 00:05:06,839
Nesse caso, a gente já está reaproveitando
parte da estrutura do Node

82
00:05:06,906 --> 00:05:11,411
que já está pronta e aí
eu só preciso rodar alguns poucos comandos

83
00:05:11,411 --> 00:05:14,414
e copiar os meus arquivos
para dentro do container.

84
00:05:14,580 --> 00:05:18,551
Nosso próximo passo então é rodar a PK

85
00:05:18,551 --> 00:05:23,122
Red pra
garantir aí que eu tenho um Python dois,

86
00:05:23,222 --> 00:05:27,827
o compilador C e o
make dentro da minha máquina.

87
00:05:27,927 --> 00:05:30,029
Nosso próximo passo então

88
00:05:30,029 --> 00:05:33,566
vai ser criar um diretório de trabalho,

89
00:05:33,633 --> 00:05:36,002
nesse caso chamado EPP.

90
00:05:36,002 --> 00:05:40,306
Esse diretório de trabalho
vai basicamente informar para o container

91
00:05:40,406 --> 00:05:43,409
qual pasta
ele deve utilizar para poder trabalhar.

92
00:05:43,409 --> 00:05:46,412
Note que todo nosso conteúdo do arquivo

93
00:05:46,479 --> 00:05:49,382
está dentro de uma pasta chamada EPP.

94
00:05:49,382 --> 00:05:52,785
Dessa forma eu vou conseguir navegar
para dentro dessa pasta,

95
00:05:52,785 --> 00:05:56,222
utilizar ela como parte da padrão
e a partir de

96
00:05:56,222 --> 00:05:58,825
então começar a executar os demais
comandos.

97
00:05:58,825 --> 00:06:04,530
O comando copy serve justamente para
copiar arquivos para dentro do container.

98
00:06:04,597 --> 00:06:09,102
Ele vai copiar todos os arquivos
da pasta que eu me encontro,

99
00:06:09,168 --> 00:06:14,741
por isso o ponto para a pasta que eu
vou estar utilizando dentro do contêiner.

100
00:06:14,807 --> 00:06:16,309
Por isso eu vou utilizar.

101
00:06:16,309 --> 00:06:19,946
Ponto novamente
e aqui vai vir um ponto bem interessante.

102
00:06:20,012 --> 00:06:25,051
A cópia do arquivo não é exatamente
uma boa prática, como a gente viu.

103
00:06:25,118 --> 00:06:28,321
Se a gente não souber
utilizar o armazenamento de arquivos

104
00:06:28,321 --> 00:06:32,692
de forma correta, isso vai atrapalhar
o bom funcionamento de um ponteiro.

105
00:06:32,925 --> 00:06:37,530
A questão nesse caso é que,
como eu estou criando um container novo,

106
00:06:37,597 --> 00:06:42,335
eu preciso passar a todos os códigos
que vão servir de base para ele.

107
00:06:42,402 --> 00:06:47,073
Então eu posso copiar esses arquivos
sem a menor dor de cabeça,

108
00:06:47,140 --> 00:06:50,610
já que eles vão passar
a ser parte fundamental

109
00:06:50,676 --> 00:06:52,645
de todo o container que eu estou criando.

110
00:06:52,645 --> 00:06:57,016
O passo seguinte,
então, é garantir que esse meu sistema

111
00:06:57,016 --> 00:07:00,620
esteja utilizando o ambiente de produção.

112
00:07:00,720 --> 00:07:03,456
Para isso,
eu posso executar um Warning Stall.

113
00:07:03,456 --> 00:07:07,059
Esse comando é um comando
que pertence ao ambiente novo e serve

114
00:07:07,059 --> 00:07:10,430
basicamente para instalar
todos os pacotes necessários

115
00:07:10,430 --> 00:07:13,666
e preparar o ambiente para a execução
daquela minha aplicação.

116
00:07:13,766 --> 00:07:17,437
Em seguida, eu vou utilizar o C MD,

117
00:07:17,503 --> 00:07:20,206
que é basicamente uma forma de criar

118
00:07:20,206 --> 00:07:23,042
linhas de comando dentro do container.

119
00:07:23,042 --> 00:07:27,447
Nesse caso, eu estou chamando o comando
node e informando para ele

120
00:07:27,447 --> 00:07:34,187
que o arquivo de origem da minha aplicação
está dentro da pasta SCR

121
00:07:34,287 --> 00:07:35,021
index.

122
00:07:35,021 --> 00:07:38,658
E esse é exatamente
o caminho que a gente checou agora a pouco

123
00:07:38,791 --> 00:07:41,761
de onde estava o index da minha aplicação.

124
00:07:41,761 --> 00:07:45,698
Então, a partir do momento que eu copiei
esses dados para dentro do container,

125
00:07:45,765 --> 00:07:48,701
eu agora mostrei para o novo de
como executá lo.

126
00:07:48,701 --> 00:07:52,872
Por fim, eu estou fazendo um ex
pouso da porta 3000.

127
00:07:53,105 --> 00:07:56,108
Esse comando serve justamente
para eu informar

128
00:07:56,309 --> 00:08:00,313
que eu vou ter que acessar
uma porta desse conta e dessa forma,

129
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

130
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.

131
00:08:10,289 --> 00:08:15,228
Outro detalhe muito importante é que
eu tenho duas formas de executar comandos.

132
00:08:15,328 --> 00:08:18,865
O primeiro é a partir do comando run.

133
00:08:18,931 --> 00:08:22,001
O run vai simplesmente executar
aquela linha

134
00:08:22,001 --> 00:08:25,004
de comando dentro do meu container.

135
00:08:25,004 --> 00:08:28,741
Na hora que eu estiver fazendo
toda a parte de construção dele.

136
00:08:28,875 --> 00:08:32,945
Enquanto isso, sem MD,
vão ser comandos que vão ser executados

137
00:08:33,012 --> 00:08:35,515
posteriores à criação do meu container.

138
00:08:35,515 --> 00:08:37,517
Dessa forma, quando eu crio lá o C.

139
00:08:37,517 --> 00:08:41,420
MD chamando um comando novo
e passando o index,

140
00:08:41,521 --> 00:08:46,692
toda vez que esse container for colocado
em execução, esse comando vai ser chamado.

141
00:08:46,759 --> 00:08:49,762
Agora que todo esse processo
está finalizado,

142
00:08:49,996 --> 00:08:52,698
eu posso utilizar esses arquivos

143
00:08:52,698 --> 00:08:56,936
para construir o meu container,
utilizando então o prompt de comando.

144
00:08:57,003 --> 00:09:01,307
Eu vou poder recorrer a uma função chamada

145
00:09:01,407 --> 00:09:02,975
Docker build.

146
00:09:02,975 --> 00:09:06,846
Esse comando é um comando bem simples
e não tem muita coisa que a gente deve

147
00:09:06,846 --> 00:09:08,281
configurar nele.

148
00:09:08,281 --> 00:09:12,785
Nesse caso, por exemplo,
a gente só vai nomear a imagem

149
00:09:12,852 --> 00:09:16,722
e em seguida informar o endereço
do Dockerfile que vai ser utilizado.

150
00:09:16,789 --> 00:09:20,459
Para isso
eu vou informar o menos ter seguido

151
00:09:20,459 --> 00:09:23,462
do nome da imagem,

152
00:09:23,629 --> 00:09:26,399
nesse caso vou chamar ela de Olá

153
00:09:26,399 --> 00:09:29,268
e em seguida eu vou informar um ponto.

154
00:09:29,268 --> 00:09:34,106
A função desse ponto
é para informar que eu já estou na pasta

155
00:09:34,173 --> 00:09:37,710
aonde eu tenho o Dockerfile,
caso não esteja nessa pasta,

156
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

157
00:09:43,649 --> 00:09:48,087
e esse endereçamento
vai variar entre sistemas operacionais.

158
00:09:48,154 --> 00:09:51,857
A forma mais fácil
então é utilizar os comandos de navegação

159
00:09:51,857 --> 00:09:56,329
de terminal como CD
para poder navegar pelos diretórios

160
00:09:56,429 --> 00:09:59,365
e chegando no diretório
que tem o Dockerfile

161
00:09:59,365 --> 00:10:03,803
ou simplesmente executar o Docker build
com o ponto no final.

162
00:10:03,903 --> 00:10:06,772
Executando então o processo de build,

163
00:10:06,772 --> 00:10:08,975
várias coisas vão ser executadas.

164
00:10:08,975 --> 00:10:12,345
A primeira delas
é todo download de imagens,

165
00:10:12,445 --> 00:10:15,748
seguido da construção das aplicações

166
00:10:15,815 --> 00:10:19,552
e todo o teste de funcionamento
para ver se o comando inicial

167
00:10:19,552 --> 00:10:21,253
vai ser executado com sucesso.

168
00:10:21,253 --> 00:10:24,256
Caso você
possua alguma falha nesse processo,

169
00:10:24,423 --> 00:10:27,893
você pode recorrer ao Docker Logs.

170
00:10:27,960 --> 00:10:31,931
Esse é um comando que permite a gente
checar logo o ambiente Docker.

171
00:10:32,031 --> 00:10:35,635
Inclusive é legal que você pode utilizar
ele para checar logs

172
00:10:35,635 --> 00:10:40,506
individualmente de cada contêiner
com o processo de build concluído.

173
00:10:40,573 --> 00:10:45,311
O Docker sempre vai perguntar se você não
quer fazer um scan de vulnerabilidades.

174
00:10:45,411 --> 00:10:47,880
Nesse caso, não vai ser preciso.

175
00:10:47,880 --> 00:10:50,082
A única coisa que nos falta agora

176
00:10:50,082 --> 00:10:52,885
é colocar justamente
esse container em execução.

177
00:10:52,885 --> 00:10:56,222
Para isso a gente vai recorrer ao comando
docker run.

178
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.

179
00:11:00,459 --> 00:11:03,396
O primeiro parâmetro vai ser justamente
para garantir

180
00:11:03,396 --> 00:11:07,033
que essa imagem vai ficar em execução
o tempo todo.

181
00:11:07,133 --> 00:11:09,769
Para isso, vou utilizar ao menos o D,

182
00:11:09,769 --> 00:11:12,772
enquanto o segundo parâmetro menos p,

183
00:11:12,772 --> 00:11:17,376
vai ser para informar o apontamento de
portas de rede.

184
00:11:17,443 --> 00:11:20,046
Dessa forma,
todo o conteúdo da minha aplicação

185
00:11:20,046 --> 00:11:23,449
vai ficar disponível
para acesso para executar então

186
00:11:23,549 --> 00:11:28,921
o container que a gente acabou de criar,
eu vou fazer um Docker run

187
00:11:29,021 --> 00:11:33,325
em menos de

188
00:11:33,392 --> 00:11:36,395
menos P para informar a porta

189
00:11:36,429 --> 00:11:39,765
e nesse caso eu expus a porta 3000.

190
00:11:39,865 --> 00:11:44,236
Então vou utilizar 3002 pontos, 3000.

191
00:11:44,336 --> 00:11:46,439
A razão de eu ter que repetir O31000

192
00:11:46,439 --> 00:11:50,142
duas vezes
é porque eu estou falando de duas portas.

193
00:11:50,209 --> 00:11:53,446
A primeira é a porta na minha máquina base

194
00:11:53,546 --> 00:11:58,484
e a segunda é a porta do meu container,
que específico por exemplo,

195
00:11:58,484 --> 00:12:02,188
a primeira porta,
que é a da máquina base, como 80.

196
00:12:02,254 --> 00:12:04,790
Ela vai apontar um acesso

197
00:12:04,790 --> 00:12:07,993
realizado na porta 80 do meu servidor base

198
00:12:08,094 --> 00:12:12,131
para a porta 3000 do meu container.

199
00:12:12,198 --> 00:12:15,201
Isso é algo que a gente tem que prestar
bastante atenção.

200
00:12:15,434 --> 00:12:17,703
Às vezes,
quando a gente vai criar uma aplicação,

201
00:12:17,703 --> 00:12:22,141
a gente tem vários containers
que tem expostas a porta 80

202
00:12:22,374 --> 00:12:26,912
e eu posso apontar diversas portas
para dentro desses containers,

203
00:12:26,979 --> 00:12:30,683
utilizando numerações diferentes
no meu rosto base.

204
00:12:30,783 --> 00:12:37,123
O próximo passo então é informar o nome da
minha imagem, nesse caso o LA

205
00:12:37,189 --> 00:12:39,091
colocando a imagem em execução

206
00:12:39,091 --> 00:12:42,261
eu vou receber o código de validação dela

207
00:12:42,361 --> 00:12:45,331
e se eu executar um Docker PRS?

208
00:12:45,364 --> 00:12:49,068
Note que essa minha imagem
já se encontra em execução

209
00:12:49,168 --> 00:12:53,372
e me informando que a porta 3000
está apontando para a porta

210
00:12:53,372 --> 00:12:55,741
3000 do contêiner.

211
00:12:55,741 --> 00:12:59,311
O último passo
então, é abrir o navegador web

212
00:12:59,378 --> 00:13:03,983
e acessar
justamente a nossa máquina na porta 3000.

213
00:13:04,083 --> 00:13:07,086
O IP que eu informei aqui 127,0

214
00:13:07,086 --> 00:13:10,990
ponto zero
ponto um é o que se chama de local Rust.

215
00:13:11,056 --> 00:13:13,759
Ele representa a própria máquina na rede.

216
00:13:13,759 --> 00:13:19,732
Outra forma que você teria era escrever
por extenso local rows de 2,3000.

217
00:13:19,832 --> 00:13:21,467
Qualquer uma das duas formas

218
00:13:21,467 --> 00:13:25,304
já faria com que toda a interface
funcionasse normalmente.

219
00:13:25,404 --> 00:13:28,407
No nosso caso, após acessar a aplicação,

220
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

221
00:13:33,312 --> 00:13:39,652
e eu consigo, por exemplo, ir adicionando
itens dentro dessa minha aplicação.

222
00:13:39,852 --> 00:13:42,688
Esse é um exemplo de uma aplicação
bem simples,

223
00:13:42,688 --> 00:13:47,293
só pra gente entender como é que eu começo
a construir todo esse ambiente.

224
00:13:47,359 --> 00:13:50,596
A partir de agora,
você pode utilizar esses conhecimentos

225
00:13:50,696 --> 00:13:54,200
para começar a renderizar
as suas próprias aplicações

226
00:13:54,300 --> 00:13:58,304
e com isso entender um pouco mais
de como todo esse ecossistema funciona.