https://github.com/lucasrmagalhaes/criando_containers-docker
Docker: Criando containers sem dor de cabeça.
https://github.com/lucasrmagalhaes/criando_containers-docker
alura docker
Last synced: 6 months ago
JSON representation
Docker: Criando containers sem dor de cabeça.
- Host: GitHub
- URL: https://github.com/lucasrmagalhaes/criando_containers-docker
- Owner: lucasrmagalhaes
- License: mit
- Created: 2022-02-04T23:13:31.000Z (over 4 years ago)
- Default Branch: main
- Last Pushed: 2022-02-07T02:34:32.000Z (over 4 years ago)
- Last Synced: 2025-03-26T19:17:15.235Z (over 1 year ago)
- Topics: alura, docker
- Language: JavaScript
- Homepage:
- Size: 476 KB
- Stars: 4
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
**Docker:** Criando containers sem dor de cabeça.
**A evolução do host de aplicações**
Antigamente... Várias aplicações, vários servidores.
Capacidade pouco aproveitada.
Muito tempo ocioso!
Muitos recursos desperdiçados!
**Melhorando a situação: Virtualização**
APP - VM -> Hypervisor -> S.O. (Um Sistema Operacional para cada VM) -> Hardware
**Nem tudo são flores... o problema das VMs.**
Quanto mais VMs, mais custos de hardware - processamento, configuração, atualização, segurança e tempo.
**Então como melhorar agora? A era dos containers!**
APP - Container - SO (Um Sistema Operacional para todos os containers) - Hardware
Mais leve
Não tem os custos de manter múltiplos S.O.
Mais rápido de subir
**Ganhamos:**
Melhor controle sobre o uso de cada recurso (CPU, Disco, Rede... etc)
Agilidade na hora de criar ou remover um container
Maior facilidade na hora de trabalhar com diferentes versões de linguagens e bibliotecas
Mais leves que as VM
**Docker**
Docker Inc. - A empresa
Docker - A tecnologia de containers
Tecnologias de containers para prover ferramentas modernas para deployar e rodar aplicações.
**Docker Engine:** Tecnologia mais famosa e responsável por fazer o meio de campo entre os containers e o SO.
**Docker Compose:** Um jeito fácil de definir e orquestrar múltiplos containers.
**Docker Swarm:** Uma ferramenta para colocar múltiplos Dockers Host's para trabalharem juntos em cluster.
**Docker Hub:** Um repositório com mais de 250 mil imagens diferentes para os seus containers.
**Docker Machine:** Uma ferramenta que nos permite instalar e configurar em host virtuais.
Exibe a versão do docker.
```
docker version
```
Cria um container com a respectiva imagem passada como parâmetro.
```
docker run hello-world
```
[Play With Docker](https://labs.play-with-docker.com/)
Basta clicar em +Add New Instance e começar a utilizá-lo como estivesse usando sua máquina normalmente.
```
docker run ubuntu
```
Lista todos os containers.
```
docker ps -a
```
```
docker run ubuntu echo "Olá Mundo"
```
Dentro do Container, consegue rodar comandos nativos da Imagem do Container.
```
docker run -it ubuntu
```
Lista só os containers ativos.
```
docker ps
```
exit ou Ctrl + d -> Sai do container.
Iniciar o container
```
docker start container_id
```
Parar o container
```
docker stop container_id
```
Acessar o container no modo interativo
```
docker start -a -i container_id
```
Remover um container
```
docker rm container_id
```
Remover containers inativos
```
docker container prune
```
Listar imagens
```
docker images
```
Remover imagem
```
docker rmi nome_imagem
```
Baixar uma imagem com a versão informada
```
docker run ubuntu:14.04
```
**Layered File System**
Toda imagem que baixamos é composta de uma ou mais camadas.
Essas camadas podem ser reaproveitadas em outras imagens, acelerando assim o tempo de download.
Imagem não oficiais, criado por pessoas, informar o username/imagem
```
docker run dockersamples/static-site
```
-d -> detached, roda em background, liberando o terminal
```
docker run -d dockersamples/static-site
```
-t -> tempo, padrão é 10 segundos
```
docker stop -t 0 container_id
```
-P -> container atribui a porta aleatória
```
docker run -d -P dockersamples/static-site
```
Verificar a porta
```
docker port container_id
```
Definir um nome para o container
```
docker run -d -P --name meu-site dockersamples/static-site
```
Parar o container pelo o nome
```
docker stop -t 0 meu-site
```
Definir a porta que o container vai rodar - localhost:12345
```
docker run -d -p 12345:80 dockersamples/static-site
```
- e -> Variável de Ambiente
```
docker run -d -P -e AUTHOR="Lucas Magalhães" dockersamples/static-site
```
-q -> Retorna os IDs
```
docker ps -q
```
Para os containers com um comando só, útil para parar vários containers
```
docker stop -t 0 $(docker ps -q)
```
**Containers são voláteis:** Aonde salvar o código? Logs? Dados? Nos volumes!
/var/www -> Docker Host
-v -> Especifica o caminho
```
docker run -v "/var/www" ubuntu
```
Informações do container
```
docker inspect container_id
```
Mounts -> Source -> Informa onde está salvando os dados localmente.
```
docker run -it -v "C:\Users\Lucas\Desktop:/var/www" ubuntu
```
```
cd var/www/
```
```
touch novo-arquivo.txt
```
```
echo "Este arquivo foi criado dentro de um volume" > novo-arquivo.txt
```
**Por que usamos volumes?**
Muitas vezes removemos os containers após o uso. Volumes são usados para os dados que não devem ser removidos.
É muito comum usar o container e apagá-lo após seu uso. Dessa forma também são removidos os dados desse container e aí entram os volumes que permitem salvar dados fora do container.
**Um volume fica salvo:** No Docker Host
Fica salvo no computador onde a Docker Engine está rodando.
Informando o caminho e rodando o projeto - CAMINHO_HOST:CAMINHO_CONTAINER
```
docker run -d -p 8080:3000 -v "C:\Users\Lucas\Desktop\volume-exemplo:/var/www" -w "/var/www" node npm start
```
Dentro da pasta e rodando o projeto
```
docker run -d -p 8080:3000 -v "$(pwd):/var/www" -w "/var/www" node npm start
```
Build
```
docker build -f node.dockerfile -t lucasrmagalhaes/node .
```
Listando imagens
```
docker images
```
Remove e força o stop
```
docker rm -f container_id
```
Rodando a imagem criada
```
docker run -d -p 8080:3000 lucasrmagalhaes/node
```
Login do Docker HUB
```
docker login
```
Subindo a imagem
```
docker push lucasrmagalhaes/node
```
Baixando a imagem
```
docker pull lucasrmagalhaes/node
```
Mostra o ip atribuído ao container pelo docker (funciona apenas dentro do container)
```
hostname -i
```
Ativando o comando ping no Ubuntu
```
apt-get update && apt-get install -y iputils-ping
```
Cria uma rede especificando o driver desejado
```
docker network create --driver bridge minha-rede
```
Listando as redes
```
docker network ls
```
Cria um container especificando seu nome e qual rede deverá ser usada
```
docker run -it --name meu-container-de-ubuntu --network minha-rede ubuntu
```
```
docker run -it --name meu-segundo-container-de-ubuntu --network minha-rede ubuntu
```
```
ping meu-container-de-ubuntu
```
```
docker pull douglasq/alura-books:cap05
```
```
docker pull mongo
```
Startando o mongo
```
docker run -d --name meu-mongo --network minha-rede mongo
```
Startando o projeto
```
docker run --network minha-rede --name alura-books -d -p 8080:3000 douglasq/alura-books:cap05
```
Salva os livros no banco
```
http://localhost:8080/seed
```
**Subir 5 containers na mão?** Não!
Docker Compose salva nossa vida!
docker-compose.yml
Buildar
```
docker-compose build
```
Rodar os containers
```
docker-compose up
```
Rodar em background
```
docker-compose up -d
```
Listar os serviços
```
docker-compose ps
```
Para e remove
```
docker-compose down
```
```
docker exec -it alura-books-1 ping alura-books-2
```
```
docker-compose restart
```