APRENDA DOCKER DO ZERO | TUTORIAL COMPLETO COM DEPLOY

Imagine que nós somos chefes de cozinha você é vergonha da professional e criamos uma receita incrível mas ao tentar preparar essa mesma receita em uma outra cozinha algo dá errado os ingredientes são diferentes o forno não aquece da mesma maneira e no final o resultado não é tão bom essa analogia é muito boa pra gente entender o motivo da existência do docker que é a compatibilidade entre diferentes ambientes e a facilidade do Deploy da nossa aplicação nesses diferentes ambientes então se você quer aprender Como o docker funciona e colocar esses conceitos em prática fica ligado

até o final desse vídeo porque a gente vai aprender vários comandos super importantes do docker e no final a gente vai fazer o Deploy de uma aplicação dockerizar na VPS então sem mais enrolações Bora pro vídeo Então a primeira dúvida que deve ter surgido na mente de vocês é o que que é o docker e para que que ele serve então começando pela primeira dúvida O que que é o docker o docker é um serviço de virtualização o que que isso significa o docker permite que a gente crie a nossa aplicação independente do ambiente onde

a gente está desenvolvendo então através de um serviço de virtualização a gente vai conseguir fazer o Deploy da nossa aplicação contendo todas dependências necessárias pra execução da aplicação então o docker o que que ele vai fazer ele vai pegar no Nossa aplicação e colocar ela dentro de um contêiner esse contêiner ele é totalmente independente das outras coisas dos outros processos que estão rodando na nossa máquina e ele contém dentro dele somente as coisas necessárias para executar a nossa aplicação então separa as aplicações em contêiners vocês devem estar pensando tá isso é parecido com virtual machines

Qual é a diferença do docker para uma máquina virtual o docker dentro de cada contêiner não precisa ter um sistema operacional então o Dock ele utiliza o sistema operacional do computador hospedeiro só que ele faz essa divisão dos recursos entre os contêiners e cada contêiner roda de maneira independente e não enxerga o outro container que tá rodando Então apesar de utilizar o mesmo sistema operacional do hospedeiro diferente nas máquinas virtuais em cada uma delas a gente precisa fazer também a instalação do sistema operacional etc o contêiner ele vai utilizar o sistema operacional do hospedeiro só

que ele não vai enxergar as outras coisas que estão rodando no PC do hospedeiro ele vai enxergar somente ali a visão dele né as coisas que dizem respeito a ele e essa divisão ela é feita através de C groups e nam spaces tá então através do C groups e nam spaces a gente vai fazer que cada container ele tem ali seus recursos individuais então cada container Tem uma parte dos recursos da máquina de maneira individual tá uma parte da memória uma parte da CPU etc ele também aqui os C groups e namespaces vai fazer com

que tenha ali um sistema de rede individual para cada com container também então separa a rede né separação de interface de rede vai fazer também com que cada um tenha suas variáveis de sistema cada contêiner é como se fosse o sistema operacional do hospedeiro Zerado sem nada dentro né rodando ali seus próprios processos tendo suas próprias dependências totalmente apartado das Outras aplicações que estão rodando no hospedeiro só que a grande sacada aqui do docker é justamente esse ponto de não precisar baixar um sistema operacional em cada contêiner por utilizar o sistema operacional do hospedeiro a

gente tem aqui um contêiner muito mais leve né do que se a gente tivesse rodando máquinas virtuais porque quando a gente utiliza máquinas virtuais a gente também tá fazendo uma virtualização então a gente tá usando o mesmo hardware físico para rodar mais de uma máquina dentro então a gente tá virtualizando máquinas né criando máquinas virtuais só que as máquinas virtuais cada uma delas vai ter um sistema operacional então no mesmo computador eu posso ter três máquinas virtuais cada uma rodando um sistema operacional diferente uma rodando Windows outra rodando o bunt e outra rodando o macos

quando a gente tá falando de docker a gente vai ter a mesma máquina física rodando vários contêiners Só que os contêiners t o mesmo sistema operacional da máquina Hospedeira A diferença é que os contêiners eles não vão ter a visão dos outros contêiners que estão rodando ali na máquina só que né eles vão estar usando o mesmo sistema operacional da máquina Hospedeira então isso torna os contêiners uma solução muito mais leve do que máquinas virtuais Então agora que a gente já entendeu o que é o docker a gente pode para partir para responder a pergunta

de por utilizar o docker e essa resposta aqui é muito mais simples do que vocês podem estar imaginando sabe aquele problema que a gente sempre passa quando a gente é programador que é o famoso na minha máquina funciona com o docker a gente não vai ter esse problema de na minha máquina funciona por quê Porque a gente vai virtualizar através do docker todo o ambiente necessário para rodar a nossa aplicação todas as dependências que são necessárias todas as configurações que precisam ser feitas no sistema operacional tudo tá a gente vai virtualizar e colocar tudo dentro

do contêiner então quando eu rodar o contêiner na minha máquina eu tô rodando ali aquele pacotinho que tem tudo necessário para rodar a minha aplicação Quando eu for rodar essa minha aplicação em outra máquina por exemplo a máquina lá da WS onde eu vou fazer o Deploy da minha aplicação tem que rodar exatamente igual porque o ambiente está virtualizado então a gente resolve o problema de na minha máquina Funciona porque a gente virtualiza o ambiente e a gente para de ser dependente disso de ah na minha máquina tá assim na minha máquina tá assado não

com o docker a gente faz todas as configur ações no contêiner Então tudo isso aqui fica salvo no contêiner a gente virtualiza o ambiente dessa maneira tendo o mesmo contêiner vai executar ali em todas as máquinas da mesma maneira então a gente utiliza o docker para resolver o problema de na minha máquina funciona e conseguir fazer com que a nossa aplicação Rode da mesma maneira em Ambientes diferentes Então agora que a gente já entendeu aqui o que é o docker e porque utilizar o docker Vamos partir para próximo passo então agora vamos entender alguns conceitos

básicos aqui do docker que fazem parte da taxon omia aqui básica que a gente vai ouvir falar bastante que seriam os docker files os containers as imagens e os registros começando pelos docker files os docker files são arquivos que a gente vai ter dentro da nossa aplicação que eles são como se fosse um projeto da arquitetura da nossa aplicação para que ela funcione corretamente então dentro dos docker files a gente vai ter todas as informações necessárias para gerar a nossa imagem do docker e essa imagem do docker ela vai conter ali todas as coisas necessárias

para rodar a minha aplicação é como como se fosse uma imagem do ambiente necessário para executar a minha aplicação os contêiners pro outro lado eles são uma Instância de uma imagem tá então eles são literalmente uma imagem só que rodando a imagem contém as informações do ambiente e uma instância é o contêiner é é aquele ambiente executando quando a gente cria um novo contêiner né quando a gente inicia um novo contêiner a gente inicia um processo na máquina Hospedeira a máquina Hospedeira pode ser tanto uma VM então uma máquina virtual que está rodando em cima

de outra máquina física ou pode ser diretamente já uma máquina física como por exemplo o nosso computador aqui que a gente tá utilizando Então dessa maneira eu consigo ter vários contêiners executando no mesmo hospedeiro né Inclusive eu posso ter várias estâncias da mesma imagem rodando então eu posso ter a minha aplicação rodando três vezes dentro da mesma máquina Hospedeira né criando três contêiners diferentes três estâncias diferentes da mesma imagem e por fim os registros Eles são um Hub que concentram imagens do docker né são lugares onde a gente utiliza para armazenar essas imagens para que

essas imagens consigam ser reutilizadas depois né por outras pessoas ou pelo meu próprio time esses hubs eles estão espalhados por aí então tem vários hubs como por exemplo a aws tem seu próprio Hub né que é o aws registry a azure também tem um deles tem o docker Hub que lá concentra várias imagens criadas pela comunidade e diversos outros então nesses hubs a gente pode pegar imagens que já existem e reaproveitar como por exemplo a imagem do node né que já vai trazer o node instalado ali no contêiner PR A gente consegui utilizar a imagem

do dnet do Java do PHP tem imagem também para site estático que já vem ali todas as coisas necessárias para rodar um site stat E por aí vai então agora vamos partir pra mão na massa e vamos aprender alguns comandos básicos do docker para então criar ali o docker file de uma aplicação Java que a gente vai fazer o Deploy mas para isso primeiro a gente precisa aprender alguns comandos antes da gente rodar esses comandos a gente precisa ter o docker instalado na nossa máquina então se você ainda não tem o docker instalado entra aqui

no site do docker vai em started e aqui faz o download do docker de acordo com o seu sistema operacional no meu caso aqui é pro macos então eu já tenho ele instalado aqui com o docker instalado a gente vai poder abrir o nosso terminal e então executar aqui os comandos né do docker pra gente aprender o primeiro comando que a gente vai aprender é para saber quantos contêiners e quais são os contêiners que estão executando a nossa máquina então vou fazer aqui um docker PS e ele vai nos trazer aqui uma tabelinha essa tabelinha

vai me dizer o container ID então o ID único de cada contêiner a imagem do qual esse contêiner deriva né porque lembrando o contêiner é uma estância dessa imagem uma estância tá executando o comando utilizado né ali pra inicialização do contêiner quando ele foi criado Qual é o status se ele tá rodando se ele tá pausado etc qual as portas e como é que elas estão mapeadas isso aqui a gente já vai entender depois e o nome aqui do contêiner no meu caso não tem nenhum contêiner rodando então ele não tá mostrando nada então pra

gente ver aqui como é que fica quando um contêiner tá rodando a gente vai fazer o seguinte a gente vai vir aqui e vamos fazer docker Run e vamos colocar hello world e esse hello world esse hello world é uma imagem oficial do docker que tem aqui no docker Hub que é justamente uma imagem de teste só pra gente ver como é que funciona então a gente executa Esse comando aqui docker Run hello world e ele vai pegar essa imagem aqui do docker HUB E então vai rodar na nossa máquina pra gente saber se essa

imagem foi pega com sucesso ele vai logar com hello world para nós então docker Run hello world rodei aqui e a gente já consegue ver né que ele colocou aqui ó hello From docker This message shows that your installation corly Então essa mensagem mostra que a sua instalação parece estar rodando corretamente então se vocês não tiverem a imagem hello world na máquina de vocês ele vai lá e vai buscar essa imagem no docker Hub se ela já existir ele só vai executar assim rapidamente então agora vamos rodar docker PS e a gente vai ver aqui

que ele não vai mostrar nada não tem nenhuma imagem rodando Como assim porque essa imagem aqui do hello world ela inicia ele loga o Hello from docker então se não tem nenhum processo rodando dentro do contêiner o contêiner é finalizado o contêiner só vai continuar executando caso tenha algum processo lá dentro do contêiner que ainda esteja ativo que ainda esteja rodando nesse caso aqui não tem porque ele faz o Hello from docker então para não tem mais nenhum processo executando Mas se a gente quisesse ver todas os containers mesmo os que já pararam de Executar

a gente pode fazer docker PS - A então ele vai mostrar aqui tudo que já executou na nossa máquina todos os contêiners e quanto tempo faz que eles foram criados ó no meu caso ten aqui contêiners que eu executei cin dias atrás e agora 3 minutos atrás e um e um minuto atrás aqui que é o contêiner do hello world se a gente der uma olhada aqui ó ele vai ter o container ID a imagem o comando executado então para executar a imagem hello world ele executou aqui esse comando barra Hello Provavelmente tem algum arquivo

ali dentro dessa imagem algum scriptz inho ali que quando executa com barra Hello ele executa esse scriptz inho Então faz ali o log né do hello world para nós e essa imagem falando aqui que tá rodando corretamente quando foi criado um minuto atrás trás Qual é o status então o status exited né então exitou parou execução E aqui as portas e o name que no caso não tem nada ele tá até vindo para cá então agora que a gente já entendeu como é que a gente executa uma imagem como é que a gente lista os

contêiners que tem na nossa máquina vamos ver mais alguns comandos aqui se a gente quisesse rodar um Ubunto aqui na nossa máquina como é que a gente poderia fazer a gente poderia fazer docker Run Ubunto e essa imagem aqui existe tá E aí é uma imagem que contém o sistema operacional Ubunto então eu posso dar um enter aqui ó e ele vai executar e não vai fazer nada por qu vamos dar aqui um docker PS a gente vai ver que não tem nenhum contêiner rodando se a gente fizer um docker PS menos All para mostrar

todos até os que hesitaram a gente vai ver aqui ó que ele executou o bunto tá vendo mas como eu falei para vocês para que o contêiner fique ativo fique executando tem que ter um processo vivo dentro daquele contêiner quando eu executo o Ubunto somente ele inicia o Ubunto eu não rodo nada aquele dentro daquele Ubunto então ele morre de novo porque não tem nenhum processo ativo rodando dentro do contêiner para que fique um processo ativo e a gente consiga interagir com o bun a gente pode fazer o seguinte docker Run menos it e a

gente colocar o bunto E então passar B por quê Porque a gente quer iniciar aqui o processo do BH dentro do Ubunto o Bash é literalmente o terminal então a gente quer iniciar o processo do BH dentro do Ubunto e quando o processo do B tiver rodando a gente vai manter o contêiner ali ativo porque vai ter um processo executando Então esse terminal aqui que tá aberto da minha máquina ele é um processo rodando aqui dentro da minha máquina então quando eu iniciar o b lá dentro do Ubunto ele vai ser um processo também então

vamos fazer aqui ó docker Run menos it passando do bun best ele vai executar o best e para que que é esse it é pra gente conseguir interagir é de interativo Então vou dar um enter aqui e agora a gente consegue ver ele abriu aqui um outro terminal Tá vendo como se fosse ó ele iniciou um terminal dentro de Rot eu tô dentro lá do bunt agora então aqui dentro do bunt eu posso fazer um LS mostrar tudo que tem dentro aqui dentro do bunto eu posso fazer um CD home CD home posso fazer um

LS aqui dentro de home também posso fazer um diretório aqui então MK dear New Dick e ele vai criar vou dar um LS ele vai ter criado aqui o novo diretório entendeu tô dentro aqui da máquina Ubunto que tá rodando dentro desse contêiner no momento aqui eu posso abrir mais um terminal então vou fazer aqui cont control T vou abrir um novo terminal e agora se eu fizer docker PS a gente vai ver que tem um contêiner executando aqui ó a gente consegue ver que o status dele é up ele está ativo está rodando é

um container que deriva da Imagem ubunt e o comando usado para iniciar ele foi o comando BH dessa forma usando o menus zit a gente consegue abrir aqui o terminal iterativo para interagir com o que tá rodando ali dentro e passando aqui o BH a gente fez com que iniciasse o processo do BH lá dentro na nossa máquina Ubunto para que a gente conseguisse ali interagir Se eu quisesse parar a execução de todos os processos que estão rodando desse contêiner eu poderia fazer um docker Stop passando o container ID Então é isso que a gente

vai fazer a gente vai vir aqui vamos fazer docker stop e vamos passar aqui o ID do contêiner dessa forma ele vai stopar né vai parar todos os processos que estão executando dentro daquele contêiner e dessa forma vai fazer com que o contêiner pare de executar também então vamos esperar um pouquinho aqui ele faz um Stop demorado por quê para fazer o stop de uma maneira segura para não hesitar de uma vez quando ele finaliza aqui ele volta terminal para nós para que a gente consegua interagir E se a gente fizer aqui docker PS a

gente vai ver que não tem mais nada né não tem nenhum container que esteja up no momento e se a gente voltar aqui pro outro terminal a gente vai ver que ele hesitou eu não tô mais dentro aqui do best do bun eu voltei aqui pro best da minha máquina Se eu quisesse iniciar de novo esse container poderia fazer docker start né passando o container id e eu ia iniciar o mesmo container agora se eu fizer aqui docker PS a gente vai ver que tem um container rodando que é o container lá o Boom tá

executando do besh se a gente voltar aqui pro out terminal ele não voltou PR aquele BH né não posso aqui não tô conseguindo interagir com ubun como é que eu poderia voltar para interagir com esse ubun a gente poderia fazer docker eec então para executar um comando dentro de um contêiner menus it pra gente interagir e aqui a gente vai ter que colocar o id do contêiner então o que que eu quero interagir eu quero interagir com o best se a gente fizer isso ó a gente volta pro best aqui dessa máquina e aí a

gente pode provar que é a mesma máquina fazendo um Ls e aqui a gente pode mudar para home ó a gente tá vendo que a gente tá a mesma máquina fe faz um LS de novo vê se o arquivo tá ali dentro né o diretório que a gente criou Vê se ele tá aí dentro tá aqui ó New Dick o diretório que a gente criou então é a mesma máquina então a gente viu né como é que a gente inicia um contêiner como é que a gente para um contêiner como é que a gente interage

com o container que tá rodando como é que a gente faz a interação a gente entendeu também que se não tiver nenhum processo rodando dentro do container a execução dele é parada né porque não tem nenhum processo rodando ali dentro dele então acho que de comandos principais é isso que a gente precisaria ver por hora agora a gente pode partir pra criação do nosso próprio docker file para então gerar a nossa própria imagem e Então a partir dessa imagem que vai ser a imagem feita pra nossa aplicação a gente conseguir Executar a nossa aplicação e

fazer o Deploy dela uma pausinha rápida para lembrar que se você tá gostando do conteúdo desse vídeo Não esqueça de deixar seu like se inscrever aqui no canal isso não custa nada e ajuda demais esse conteúdo a alcançar novas pessoas além disso considere também se tornar um membro aqui do canal por menos de um preço de um caixo de banana você você vai ter acesso a vários vídeos exclusivos você vai ter acesso a todas as lives que ficaram salvas aqui PR os membros do canal então todo domingo tem Live code e esse conteúdo fica salvo

só PR os membros do canal você vai ter acesso também ao chat exclusivo lá no discord da comunidade e alguns outros benefícios Então por apenas R 4,99 você vai ter acesso a todos esses benefícios que vão te ajudar na sua carreira e agora bora continuar o vídeo Então a primeira coisa que a gente precisa fazer aqui dentro do nosso docker file é importar o maven né então a gente precisa trazer o maven aqui para conseguir fazer o build da nossa aplicação para isso a gente vai utilizar uma imagem do maven que já existe então aqui

a gente vai usar o comando from que é para buscar né pegar de uma imagem já existente então from maven dois pontos 3.8.4 essa aqui é a versão do maven né que eu tô pegando então eu tô usando a imagem maven na versão né qual versão dela na 3.8.4 bar jdk8 então eu tô usando aqui essa versão da imagem do maven tá isso aqui não diz respeito à versão do maven especificamente sim a versão da imagem do maven tá então eu tô usando essa versão da imagem que aqui utiliza né a versão oito do maven

então utilizando essa versão a gente vai chamar isso aqui de build então S build por quê Porque depois a gente vai utilizar esse maven aqui para fazer o build da nossa aplicação depois que a gente pegar o maven a gente vai ter que trazer aqui para dentro do nosso contêiner todos os arquivos aqui que estão dentro da nossa aplicação né porque os arquivos vai ser o que a gente vai utilizar para fazer o build eles T ali as informações o conteúdo da nossa aplicação Então a gente vai fazer um copy a gente vai fazer copy

source para dentro de onde pra Barra app bar source Então dentro do nosso contêiner vai ter uma pasta app e dentro dessa pasta app vai ter a nossa pasta source além disso a gente precisa copiar o nosso pum XML também então a gente vai fazer copy pum p XML para dentro de barra app agora a gente precisa mudar para esse diretório barra app Então a gente vai colocar aqui work dear e aqui eu vou colocar barra app quando eu estiver dentro do diretório barra app o que que eu quero fazer eu quero fazer a instalação

das dependências com o maven e o build da nossa aplicação Spring como é que a gente vai fazer isso aqui embaixo a gente vai colocar o comando do maven para fazer a instalação das dependências E então gerar o build da nossa aplicação Qual é esse comando se a gente entrar aqui no rme dessa aplicação a gente vai ver que já colocou aqui né o autor da aplicação colocou aqui ó que pra gente Executar a nossa aplicação e gerar um um jar file né que é o arquivo executável aqui do Java a gente tem que rodar

maven Clean install Então o que a gente vai colocar aqui ó a gente vai colocar Run maven Clean install porque ele vai fazer a instalação Então vai gerar o build Beleza agora a gente vai copiar esse arquivo jar que foi gerado no build da nossa aplicação para dentro de barra app bar jar Então o que a gente vai fazer copy ifen ifen from então da onde a gente vai pegar isso de dentro do build que a gente acabou de fazer né que a gente tinha importado o maven como build então from Build a gente vai

copiar o Barra app bar target bar springboot e aqui a gente pode até vir aqui no readme e copiar né bar springboot hello world 1.0 snapshot.jar então a gente pode vir aqui colar um nomezinho né esse aqui é o nome que ele vai gerar no momento de gerar o build da nossa aplicação ele vai gerar o o jar com esse nome aqui então a gente vai copiar esse jar deixa eu Minimizar aqui a parte do projeto para ficar melhor a gente vai copiar esse jar para dentro de barra app bar app.jar com o arquivo jar

copiado O que que a gente vai fazer a gente vai agora pegar o jdk né a gente precisa colocar o jdk aqui dentro do nosso contêiner da onde a gente vai pegar o jdk a gente vai pegar da imagem da Amazon então a WS ela tem uma imagem aqui pro jdk do Java que é o que a gente vai utilizar então from openjdk 2.8 bar jre bar Alpine e aqui a gente tem que deixar o build na verdade depois do jdk primeiro eu pego jdk depois eu copio aqui o jar então o que que a

gente tá fazendo aqui a gente tá pegando o maven Lá da imagem do maven e trazendo aqui para dentro do nosso coner então a gente copia todos os arquivos que estão dentro da minha pasta source e o arquivo P XML para dentro de barra app aqui dentro do contener eu troco para esse diretório bar app E então faço aqui a instalação das dependências e o Build do nosso projeto utilizando maven então eu vou lá pego a imagem do jre do Java runtime environment utilizando aqui o a imagem da WS né que é o jdk op

Pine aqui para trazer isso para dentro do nosso contêiner feito isso o que que eu faço eu copio o arquivo do build né eu copio ponto jar que tá dentro de barra target para dentro de barra app bar app.jar e para finalizar a gente vai fazer o seguinte a gente vai trocar de novo o nosso work Gear porque agora a gente não tá mais dentro de Build a gente tá dentro agora do jdk aqui a gente vai trocar pra Barra app que foi onde a gente colocou o nosso arquivo jar então barra app eu vou

colocar aqui um expose da porta 808 só pra gente saber que esse contêiner aqui ele tá expondo a porta 8080 mas depois a gente vai ter que fazer mais uma configuração para conseguir se conectar aqui nessa porta e por fim a gente vai colocar o comando que vai executar que vai iniciar a execução da nossa aplicação que vai ser aqui CMD para dizer que a gente tá rodando comandos no terminal e quais comandos vão ser esses a gente tem que passar aqui num arrei Então a gente vai rodar o comando Java menos jar né para

indicar que a gente tá executando o arquivo jar então app.jar a gente quer executar o arquivo app.jar o utilizando aqui o Java então recapitulando de novo pega o maven Lá da imagem do maven e chama ele de build né dentro desse Build a gente copia todos os arquivos dentro de source o p XML troca para dentro de app que foi onde a gente salvou esses arquivos e faz a instalação e o Build do projeto então a gente volta aqui instala o jre Java runer environment porque aqui a gente não vai precisar fazer desenvolvimento nenhum só

execução de aplicação Java copiamos lá de dentro de build o nosso arquivo jar para dentro de app bar app.jar então a gente troca troca aqui pra pasta app declara que a gente vai expor a porta 8080 então aqui coloca os comandos finais que vão ser executados na inicialização aqui desse contêiner que vai ser CMD Java menos jar para indicar que a gente tá executando um arquivo jar E então passando aqui o nome do arquivo e aqui se a gente quisesse rodar outro comando a gente colocaria aqui também né nessa nesse arrei aqui de Strings beleza

feito isso agora o que que a gente vai precisar fazer eu vou parar aqui a execução da nossa aplicação vou fazer um terminate vou abrir aqui o terminal e o que a gente precisa fazer é agora gerar uma imagem a partir desse docker file Então esse docker file ele tem todas as definições só que a gente não tem uma imagem gerada a partir dele pra gente conseguir fazer o docker Run então para isso a gente vai precisar gerar essa imagem como é que a gente vai fazer isso a gente vai fazer através do comando docker

build então o comando docker build é utilizado pra gente gerar imagens a partir de docker files a gente vai colocar aqui menos T Então a gente vai colocar Qual o nome que a gente quer D para essa nossa imagem o nome dessa minha imagem vai ser pring boot hello world e aqui na verão são 1.0 tá então tô criando aqui a imagem springboot hello world 1.0 E então eu vou botar aqui ponto por quê Porque o docker vai ser inteligente o suficiente para identificar que aqui no root dessa aplicação tem um docker file então é

o esse docker file que eu tô tentando fazer o build se se o docker fil estivesse aqui dentro de uma pasta barra docker eu teria que vir aqui e colocar barra docker e então barra e aí pegar o docker file no caso como o docker file tá direto aqui já no root da nossa aplicação eu só só coloca o ponto aqui então vamos dar um enter ó ele tá fazendo o build da nossa imagem Então vamos esperar aqui ó ele foi lá buscou a imagem do maven buscou a imagem do jre tá fazendo aqui o

download e gerando a imagem vamos esperar um pouquinho e pronto o que que ele fez aqui ele pegou o maven pegou o jdk fez todo o build da nossa aplicação instalou as dependências E então gerou a imagem com a imagem gerada a gente já consegue executar essa imagem né então a gente já consegue fazer aqui um docker Run dessa imagem então o que que eu vou fazer vou abrir aqui o terminal e vou fazer docker Run e vamos passar o nome da imagem que a gente gerou Qual é o nome a gente passou como Spring

boot hello world e aqui na versão 1.0 né foi a versão que a gente criou se a gente fizer isso e der um enter ele disse aqui que não encontrou deixa eu ver por Ah porque eu devo ter esquecido de colocar o l no World deixa eu ver aqui quando eu gerei é eu eu gerei como hello world não World Então vou tirar aqui o l é só hello world e agora deve funcionar ó perfeito tá vendo aqui ó que assim que eu iniciei que eu dei o docker Run a gente já consegue ver que

ele logou aqui o Spring boot Então quer dizer que tá com o Java instalado fez a instalação ali com o maven e tá rodando perfeitamente a minha aplicação perfeito então eu posso abrir aqui meu local host e acessar porta 8080 bar hellow e vai funcionar certo errado não vai funcionar por que não F Como assim tá executando aqui a aplicação o que que aconteceu Por que que não tá funcionando lembra que eu falei para vocês que quando a gente sobe um contêiner ele é totalmente apartado da máquina Hospedeira então ele vai ter suas próprias variáveis

de sistema vai ter a sua própria parte ali dos recursos né a gente vai destinar recursos específicos ali pro contêiner e também vai ter a separação da interface de rede então isso aqui significa que quando executou aqui no local host do meu contêiner não significa que tá executando aqui no local host porta 880 da minha máquina eles têm interface de rede separados então a minha máquina é uma coisa o contêiner é outra coisa a interface de rede aqui do contêiner não é a mesma da minha máquina eu posso ter uma aplicação rodando na porta 8080

aqui da minha máquina e uma aplicação rodando na porta 8080 do contêiner então a gente não vai conseguir acessar diretamente fazendo dessa maneira o que a gente precisa fazer é no momento de executar o contêiner eu posso fazer um mapeamento eu vou dizer olha só se o contêiner tiver alguma coisa rodando na porta 880 faz o mapeamento pra porta x da minha máquina posso mapear pra mesma porta posso mapear pra porta 8080 também ou posso colocar para rodar na porta 54 da minha máquina ou na porta 10.001 enfim o que eu escolher eu tenho que

mapear as portas do contêiner PR as portas da minha máquina porque eles não TM a mesma rede ali né não estão na mesma interface de rede Então é isso que a gente vai fazer então quando a gente for fazer aqui o docker Run a gente vai ter que fazer esse mapeamento aqui diretamente então vamos parar aqui a execução da nossa container como é que a gente vai fazer isso a gente vai fazer através de docker Stop Então vamos fazer aqui docker PS para pegar tudo que tá executando se a gente V aqui ó o nosso

contêiner tá usando a imagem Spring boot hellow World 1.0 o comando pra execução desse contêiner foi Java menos jar é app.jar ó que foi justamente aqueles comandinho que a gente colocou aqui tá vendo olha só que legal e aqui se a gente V ó a gente tá vendo uma informação aqui no ports ó ports 8080 TCP quer dizer que tem alguma coisa rodando aqui na porta 8080 né do protocolo TCP desse contêiner só que não tá mapeando pra porta 8080 do tcb aqui da minha máquina entendeu lá no contêiner tá rodando mas aqui na minha

máquina não a gente tem que fazer esse mapeamento e aqui ele deu um nome né de Medical Almeida esse nome aqui ele vai gerar aleatoriamente se a gente não colocar nada aqui tá é só uma forma de identificar o contêiner também então vamos fazer um docker Stop aqui docker stop vamos copiar aqui esse container ID paramos a execução dele vamos fazer aqui um docker pass agora tá executando só o o contêiner do bunto E vocês viram aqui ó que tinha dois contêiner executando ao mesmo tempo né Vamos parar esse do bunto também que a gente

não tá mais utilizando então docker stop passar aqui o container do bunto e agora a gente vai inicializar de novo uma nova Estância dessa nossa imagem aqui a imagem que a gente gerou só que a gente vai fazer esse mapeamento das portas né para que a gente consiga acessar a porta aqui na nossa aplicação como é que a gente vai fazer isso a gente pode fazer de duas maneiras vou mostrar primeiro a mais simples para vocês que seria basicamente passar aqui a Flag menos P colocando P maiúsculo quando a gente passar essa Flag o próprio

docker vai fazer o mapeamento aqui das portas só que ele vai fazer de forma aleatória e automática então ele vai pegar a porta 8080 que a gente colocou aqui que o nosso contêiner faz o expose dela né então é muito importante ter esse expose aqui E aí ele vai mapear esse essa porta 8080 para alguma porta que aqui da minha máquina Hospedeira Então vamos rodar aqui perfeito ó tá executando agora a gente vem aqui faz um docker pass a gente consegue ver ó tem esse essa flechinha indicando ó então ele fez o mapeamento da porta

8080 TCP lá do contêiner pra porta 55.000 aqui da minha máquina tá então vamos copiar esse número e vamos tentar acessar aqui ó vamos entrar em local host porta 55.000 e a gente vai ver que ele retorna O hello world então ele fez esse mapeamento para essa porta aqui pra gente e agora tá funcionando perfeitamente né a gente tá conseguindo acessar mas caso a gente quisesse definir a porta que isso aqui executasse a gente tem uma maneira de fazer isso também então vou fazer aqui um docker Stop vou parar a execução desse container e vou

subir aqui a execução dele de novo então vamos fazer aqui um docker Run criar uma nova Estância só que em vez de menos p a gente vai fazer menos P minúsculo e aqui a gente vai colocar a porta do hospedeiro e a porta do contêiner que a gente quer mapear então a gente coloca assim ó eu quero mapear pra porta 8080 da minha máquina então vou fazer 8080 para 8080 do contêiner dou um enter ele inicia aqui beleza vou dar um enter aqui não vai mais funcionar mas se eu trocar aqui pra porta 8080 a

gente vai ver que tá funcionando então perfeito já entendemos aqui como é que funciona né pra gente gerar a nossa imagem do docker a partir de um docker file e como é que a gente faz para executar essa imagem e também né como é que a gente faz aqui para fazer o mapeamento das portas porque provavelmente se vocês tentassem fazer a execução não iam conseguir acessar né provavelmente não com certeza não iam conseguir acessar na porta 8080 se não tivesse esse mapeamento então agora a gente já entendeu Como funciona E por que que a gente

precisa fazer isso né por conta das interfaces de redes serem separadas aqui per perfeito agora vamos finalizar fazendo o Deploy dessa nossa aplicação na nuvem vamos pegar essa nossa aplicação aqui hello world e subir ela na nuvem usando aqui o docker Então como é que a gente vai fazer o nosso Deploy eu vou utilizar uma VPS que eu já tenho aqui na hostinger então para quem não conhece a hostinger eles são parceiros aqui do canal a gente tem desconto em todos os serviços deles e eles oferecem serviços de hospedagem de site eles oferecem também serviço

de VPS que é o que a gente vai utilizar oferecem compra de domínio e várias outras coisas então para quem tá buscando aí um serviço para hospedar seu site hospedar seu servidor comprar o seu domínio teu e-mail pra sua empresa a hostinger é uma ótima opção e a gente tem desconto em todos os serviços deles utilizando o nosso cupom eu vou deixar o link aqui na descrição do vídeo e vou deixar o q code aqui na tela para quem ficou interessado Então a gente vai utilizar o servidor VPS que eu já tenho aqui na hostinger

e esse meu servidor ele é um servidor que tá rodando um Ubunto Então a gente vai pegar esse nosso bunto e vai configurar para colocar o nosso docker aqui dentro né e fazer a execução da imagem que a gente acabou de gerar e Executar a nossa aplicação primeiro de tudo a gente precisa acessar essa nossa máquina a gente vai fazer esse acesso via SSH para quem não conhece SSH ou não sabe o que é VPS quer aprender um pouco mais sobre isso eu vou deixar aqui na descrição do vídeo e aqui no card também o

link onde eu expliquei o que é VPS fiz conexão com SSH expliquei todos esses conceitos como não é o objetivo do vídeo né como não é o foco do vídeo eu não vou me concentrar nisso a gente vai se concentrar só no que diz respeito aqui éo docker então a gente vai vir aqui vamos pegar o IP da nossa máquina né e o comando para conectar via SSH vou abrir o nosso terminal e aqui dentro do terminal eu vou rodar né S sh root @ e aqui o ip da minha máquina rodando Esse comando ele

vai pedir a senha da minha chave privada beleza e já tô conectado aqui no meu VPS que tá rodando lá na hostinger conectado aqui no meu VPS O que que a gente vai fazer a gente precisa fazer a instalação do docker né porque não tem o docker aqui nessa máquina é uma máquina ubun então se eu fizer aqui ó docker menos version a gente vai ver ó que ele nem sabe ele não conhece o comando docker então a gente precisa instalar o docker aqui como é que a gente vai fazer aqui a própria hostinger Eles

já tem aqui um post explicando como é que a gente faz a instalação do docker no ubun como é que a gente faz a instalação e a configuração Então a primeira coisa que a gente precisa fazer é a atualização do nosso sistema então a gente precisa copiar aqui esses dois comandos e colar aqui que é o APT update e upgrade feito isso a gente vai ter que fazer a instalação de alguns pacotes que são pré-requisitos pra instalação do docker Então a gente vai ter que fazer aqui o sudo aptg Install e passar aqui esses pacotes

então ele pergunta aqui se eu quero continuar vou colocar que sim vamos esperar ele ter terar aqui a atualização Ele pergunta se eu quero fazer o update vou colocar Ok pronto finalizado aqui o update do nosso sistema a gente vai fazer a instalação das dependências pronto com as dependências aqui os pacotes que são para requisitos instalados a gente vai ter que adicionar os repositórios do docker Então vamos copiar esse comando aqui esse link né esse passo a passo aqui eu vou deixar na descrição do vídeo também então vamos adicionar os repositórios do docker Vamos colocar

esse comando aqui para adicionar o repositório na nossa lista de repositórios atualizar de novo aqui aqui as informações de repositório pronto garanti aqui que a gente tá instalando o docker do lugar certo aqui a gente já consegue ver da onde ele tá pegando todos os repositórios legal e aqui a saída correta Ó tem que ser version table ubun to download docker Linux ubun deixa eu ver aqui docker Linux ubun e agora por fim a gente tem que instalar o docker então fazendo sudo APT install docker ce Yes dá um ok legal agora a gente já

pode tentar fazer docker menos verion e agora a gente já consegue ver aqui que ele reconhece o docker né e mostra aqui todos os comandos que a gente pode executar Vamos tentar fazer um docker Run Hello Road PR ver o que que vai acontecer unable to find image hello world Aí ele vai lá pegou no docker Hub E então fez um Hello from docker então perfeito o docker tá rodando aqui já na nossa VPS Então vamos fazer aqui um docker PS e não tem nenhum contêiner executando Beleza então agora a gente precisa executar aquela imagem

que a gente gerou aqui dentro como é que a gente vai fazer isso a gente vai pegar a imagem que a gente gerou aqui na nossa máquina vamos jogar lá pro docker E então vamos pegar ela aqui na nossa máquina vamos puxar ela para cá então aqui no nosso intelij a gente vai ter que fazer como se fosse um push dessa nossa imagem lá pro docker Hub como é que a gente vai fazer isso tá a primeira coisa que a gente precisa fazer é logar no docker Hub ou criar nossa conta lá no docker Hub

Caso vocês ainda não tenham então aqui no terminal já tô com o docker Hub aberto com a minha conta criada né eu já tinha conta e aqui dentro do nosso account settings a gente vai entrar aqui dentro de Security e nós vamos aqui em access to né gerar um novo access token esse access token a gente vai utilizar para logar no docker aqui na nossa máquina Então vou mostrar para vocês vamos vir aqui vou colocar access token do vídeo só vou excluir esse access token depois então access token do vídeo vamos gerar esse access token

e ele vai dizer aqui ó PR você logar agora na sua máquina o que que tu precisa fazer tem que rodar o comando docker login menos U E aí o nome do teu usuário então aqui vai vir aqui vai colar docker login aqui na nossa máquina tá não na VPS Estamos aqui na nossa máquina de novo então docker login Men u e é o nome do nosso usuário Beleza quando a gente logar isso ele vai pedir uma senha Qual senha a gente vai colocar a gente vai colocar esse exess token aqui que a gente acabou

de gerar feito isso ele vai fazer aqui o login com sucesso tá no meu caso eu já tô logado aqui na na minha máquina então eu não vou completar o processo de login vou até excluir aqui esse access token né porque apareceu aqui no vídeo então com a gente logado aqui no nosso docker Hub O que que a gente vai fazer a gente vai vir aqui em reposter e vamos criar um novo reposter então vamos vir aqui Create reposter que a gente vai chamar de spring boot hello world Vamos criar ele aqui então a gente

já consegue ver aqui ó que ele diz agora para tu mandar a tua imagem lá local para dentro aqui desse teu repositório tu vai ter que fazer um docker push kdev bar springboot hello world dois pontos tag name né o nome da tag pode ser a versão da da nossa imagem Então a gente vai copiar isso aqui copiar esse comando e agora aqui no nosso terminal a gente vai gerar a nossa imagem de novo porque a gente tinha gerado a nossa imagem somente como Spring boot hello world mas eu tenho que ter aquele barra que

perd na frente né Então a gente vai fazer o seguinte a gente vai fazer docker build menos T que nem a gente tinha feito antes só que agora o nome vai ser que hiper Dev que é o nome do meu usuário lá no docker Hub então aqui vocês coloquem o nome do usuário de vocês barra e aí eu vou colocar aqui o nome da minha imagem né o nome que eu quero dar vou deixar como Spring boot hello world do mesmo nome aqui que a gente deu pro repositório tá o nome tem que ser igual

aqui então Spring boot hello world é o mesmo nome que eu vou dar aqui e eu vou colocar a tag de 1.0 porque é a versão 1.0 então 1.0 e aqui a gente a gente tem que colocar o ponto no final para dizer que a gente tá usando essa pasta aqui né a pasta do projeto como referência para ele encontrar o docker file feito isso a gente pode fazer o build ele vai fazer aqui o build muito mais rápido do que ele fez anteriormente porque ele já tem todas as camadas instaladas aqui na minha máquina

então ele já tá com maven aqui já tá com o jre já tá com o build aqui da nossa aplicação ele só precisou gerar imagem de novo com outro nome mas já estava tudo pronto aqui básicamente na minha máquina né e o docker é inteligente o suficiente para reutilizar tudo que ele já tinha feito agora o que que a gente vai fazer a gente vai fazer o bu Então a gente vai colar aquele comando lá que a gente copiou lá no docker Hub e aqui eu vou tirar o Tag name e vou trocar para 1.0

que foi a tag que eu dei né que é a tag que controla aqui a versão então docker push kdev bar springboot hello world 1.0 aqui ele vai fazer o push mesma coisa do Git tá Então imagina que a gente tá fazendo um push num repositório Git num repositório remoto então é a mesma coisa aqui Vamos esperar ele finalizar pode demorar um pouquinho pronto com o push finalizado a gente volta aqui pro docker Hub dá um um Reload e a gente já consegue ver aqui ó que já tem uma informação aqui dentro e tem uma

tag 1.0 agora como é que a gente vai fazer lá na nossa VPS então vou abrir aqui o terminal a gente tá aqui com o nosso bunto rodando a gente vai fazer um Run dessa imagem aqui então a gente vai vir aqui vou ter que conectar de novo no SSH Beleza agora a gente vai fazer docker Run hiper devv bar springboot hello world 2.1.0 ele disse aqui que ele não encontrou imagem aí ele foi lá e tá buscando a imagem do docker HUB ó tá vendo que ele tá puxando tudo aqui agora quando a gente

tentou Executar a gente consegue ver que ele deu um erro e é esse erro aqui ele disse o seguinte ó the requested image platform Linux irm 64 does not match The detected Host platform Linux amd64 o que que isso aqui quer dizer lembra que eu falei para vocês que os contêiners eles não contém sistema operacional eles rodam em cima do sistema operacional do host a minha máquina host aqui a máquina que eu fiz o build da minha imagem é um Mac já o meu host aqui que é onde eu tô tentando executar uma distância é

um Ubunto e eles não são compatíveis tá eu buei num Mac e eu tô tentando executar num Ubunto então não tá sendo compatível E é isso que ele tá me dizendo tá tentando executar uma imagem que foi buildada paraa Mac num ubom então não vai dar certo teria que executar um Mac aqui porque eu lembra como eu falei para vocês o contêiner usa o sistema operacional do host então o host Aqui tem uma plataforma Linux AMD 64 ele foi build num Linux arm64 que é uma plataforma diferente que que a gente pode fazer aqui para

resolver a gente pode fazer duas formas ou emular um ambiente no nosso host né emular um ambiente de Linux irm 64 tem como a gente fazer isso com o docker Ou a gente pode gerar uma imagem específica pra arquitetura Linux amd64 que é a específica aqui do bu que é onde tá rodando essa minha VPS tá então a gente teria essas duas opções e é isso que a gente vai fazer a gente vai aprender a Gerar imagem específica para aquela arquitetura de sistema Então vamos voltar aqui pro intelij e eu já vou colar aqui o

comando para mostrar para vocês como é que a gente vai fazer a gente vai fazer de novo docker build só que agora a gente vai passar essa Flag aqui de ifen ifen plataform tá vendo plataform e aí qual plataforma Linux amd64 eu quero fazer o Build para essa plataforma aqui e aí menos T de novo que a gente precisa fazer Hi perd Spring boot hello world 1.0 ponto então tô fazendo o build específico aqui para essa plataforma Então o que a gente vai fazer vamos dar o enter aqui vamos esperar ele finalizar ele tá tendo

que buscar aqui muitas camadas de novo porque ele tinha buscado as camadas específicas aqui pra arquitetura do Mac né como eu tô fazendo o build agora paraa outra arquitetura ele vai ter que buscar de novo essas informações lá no docker Hub nas bibliotecas de imagem pronto com o build finalizado é só a gente fazer o push novamente lá pro docker Hub só que se a gente fizer o push com o mesmo nome e com a mesma tag name ele vai sobrescrever a tag que já existia aqui a tag que a gente criou foi criada né

pra arquitetura armm 64 ó se a gente ver aqui a gente consegue ver ó o os Qual é o sistema operacional é um Linux porque o Mac OS no final é baseado na arquitetura do Linux mas a arquitetura aqui a RM 64 se a gente fizer um push com o mesmo nome com a mesma tag ele vai sobrescrever então a gente vai criar uma nova tag específica para essa arquitetura amd64 então eu vou colar aqui de novo um comandinho que é o comandinho docker Tag aí a gente passa o nome da da imagem que a

gente acabou de gerar e a tag específica que a gente quer dar para ela pra gente não fazer o override lá no docker Hub então a gente tá só renomeando aqui local na nossa máquina antes da gente fazer o push então aqui se Vocês conseguem ver ó a gente faz um docker tag aí passa o nome da imagem local e o nome da tag que eu quero dar específico para ela que vai ser o mesmo nome kerd bar springboot bar hello world 2. 1.0 só que eu vou botar no final esse amd64 feito isso eu

dei uma nova tag agora eu vou fazer docker push e eu vou passar hiper Dev bar Spring boot hello world 1.0 só que aqui em vez de ser só 1.0 eu vou mandar o amd64 agora ele vai fazer o push vamos esperar aqui um pouquinho e com o push finalizado a gente volta lá pro docker Hub dá um relo aqui e a gente já consegue ver ó que agora tem duas tags aqui dentro Ó tem a 1.0 que foi criada pra arquitetura RM 64 e tem a 1.0 amd64 que foi criada pra arquitetura amd64 legal

né agora lá na nossa VPS a gente vai pegar essa imagem aqui com essa tag aqui que foi criada especificamente pra arquitetura do Linux da nossa VPS então voltando aqui pra VPS a gente vai fazer ó vamos logar aqui de novo ele deslogou agora que o que que eu vou fazer docker Run e eu vou passar aqui kerd bar Spring boot bar hello world dois pontos 1.0 ifen amd64 né para pegar aqui a versão específica vamos rodar ele disse que não encontrou local foi lá tá pegando do docker HUB perfeito pegou aqui do docker HUB

agora ele vai executar e pronto ó ele conseguiu Executar a nossa aplicação Spring agora dentro aqui da nossa VPS e para ficar melhor ainda né O que que a gente poderia fazer aqui fazer o mapeamento das portas né então a gente pode vir aqui parar a execução Então vamos abrir aqui de novo mais um terminal vou me conectar no SSH legal agora faço um docker PS tô vendo aqui que tá rodando um contêiner vou parar a execução desse contêiner então docker stop parei a execução do contêiner E agora o que que eu vou fazer vou

fazer um docker Run passando kerd barra Spring boot hello world 1.0 amd64 e aqui eu vou fazer o mapeamento da porta menos P de 8080 para 8080 pronto ele inicializou aqui já a execução da aplicação agora o que que a gente vai fazer né Vamos pegar aqui o endereço IP dessa minha máquina Vamos tentar acessar aqui o endereço IP no navegador ele não vai conseguir acessar porque não tem nada aqui vamos fazer aqui um continuar Ele disse que tá eguro não tem nada mas se eu trocar para 2.880 bar Hello a gente deveria ver aqui

o hello world E é exatamente o que tá acontecendo ó a gente tá vendo aqui o hello world então tô acessando aqui o meu contêiner do docker que tá rodando lá dentro da minha VPS rodando lá na nuvem lá na R Hoster Então olha só que legal tudo que a gente viu aqui hoje a gente aprendeu a Gerar nossas imagens né específicas pra nossa aplicação a gente aprendeu a Gerar imagem diferente para cada arquitetura e além de tudo a pegar essa nossa imagem e conseguir executar dentro da nuvem né e colocar para rodar E então

acessar aqui o nosso servidor de forma remota acessando lá ele tá rodando lá dentro da VPS então perfeito finalizamos aqui com chave de ouro e se você quer se aprofundar ainda mais no mundo do backend Eu recomendo que você Assista esse vídeo aqui onde eu expliquei o que é uma VPS como ela funciona e como é que a gente pode usar o protocolo SSH para se comunicar remotamente com essas máquinas eu gostaria de aproveitar esse momento para agradecer todos os membros aqui do canal por todo o carinho e todo o suporte e um agradecimento especial

a todos os membros seniors aqui do canal Vocês moram no meu coração é isso galera e até o próximo vídeo