Comandos Docker para administrar containers e imagens

1.
1-Comandos Docker inicial

sexta-feira, 20 de novembro de 2020 21:51
Comando listar as imagens

docker images
---------------------------------------------------------------------------------------------------------------------
Baixar imagens
docker pull ubuntu:18.04
Obs: Por padrão é baixado a versão latest

---------------------------------------------------------------------------------------------------------------------
Execução da imagem
docker run ubuntu:18.04
---------------------------------------------------------------------------------------------------------------------
Listar as imagens em execução ativos
docker ps
---------------------------------------------------------------------------------------------------------------------
Listar as imagens que já estavam em execução
docker ps -a
---------------------------------------------------------------------------------------------------------------------
Interagir , abrir terminal e remover após sair
docker run --rm -it ubuntu:18.04
---------------------------------------------------------------------------------------------------------------------
Interagir , abrir terminal e executar em backgroud
docker run --rm -itd ubuntu:18.04
---------------------------------------------------------------------------------------------------------------------
Interagir , abrir terminal e executar em backgroud e criar nome ao container
docker run --name MARCELO --rm -itd ubuntu:16.04
---------------------------------------------------------------------------------------------------------------------
Interagir , abrir terminal e executar em backgroud e chamar um shell
docker run -itd ubuntu:18.04 sh
---------------------------------------------------------------------------------------------------------------------
Rodar um comando que o container suporta
docker run ubuntu:18.04 ps -aux
---------------------------------------------------------------------------------------------------------------------
Rodar um comando em uma imagem baixando a imagem em backgroud
docker run --name PING -d busybox ping 127.0.0.1 -c 15
---------------------------------------------------------------------------------------------------------------------
Verificar quais containers etao rodando por quanto tempo
whatch docker os
---------------------------------------------------------------------------------------------------------------------
Executando a ferramenta nmap a partir de um containe baixado do Docker hub
https://hub.docker.com/r/uzyexe/nmap/
sudo docker run uzyexe/nmap nmap -sS 127.0.0.1
---------------------------------------------------------------------------------------------------------------------
Executando a ferramenta nmap a partir de um container existente
sudo docker run -it ubuntu:18.04 bash
#apt-get update && apt-get install nmap

#nmap -sS 127.0.0.1
exit
---------------------------------------------------------------------------------------------------------------------
Parando a execução de um container
docker stop MARCELO
---------------------------------------------------------------------------------------------------------------------
Página 1 de Docker
1-Instalando Docker Ubuntu
Ubuntu
Plataforma: 64 bits e kernel superior a 3.10
Versões Suportadas: Yakkety 16.10, Xenial 16.04 (LTS), Trusty 14.04 (LTS)
* Somente na versão Trusty 14.04 (LTS) - Executar os seguintes comandos:
sudo apt-get update
sudo apt-get install linux-image-extra-$(uname -r) linux-image-extra-virtual
Instalação
1 - Suporte a HTTPS no uso do apt
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
2 - Adicionar chave GPG Docker Oficial
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
3 - Verificar a integridade da chave (key fingerprint = 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C
0EBF CD88)
sudo apt-key fingerprint 0EBFCD88
4 - Adicionar repositório Docker 'stable'
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu

$(lsb_release -cs) stable"
5 - Atualizar lista de repositórios:
sudo apt-get update
6 - Instalar Docker-CE:
sudo apt-get install docker-ce
Se exibir informações sobre a plataforma Docker, tudo foi instalado corretamente!!
Fonte: https://docs.docker.com/engine/installation/linux/ubuntu/
--------------------------------------------------------------------------------------------------------------
Criando acesso web -Portainer.io
Página 2 de Docker
1.2-Mão na massa - "Hello Docker"
01 - Baixar a imagem base do Debian oficial
sudo docker pull debian
02 - Verificar todas as imagens contidas no repositório local (atente-

se para os campos REPOSITORY / TAG / IMAGE ID):
sudo docker images
03 - Criar um container a partir da imagem base Debian:
sudo docker run debian
OBS: como não foi usado nenhum parâmetro opcional, o container irá
iniciar e, logo em seguida, parar
04 - Listar os containers ativos (iniciados) na Engine Docker:
sudo docker ps
05 - Listar TODOS os containers (ativos e inativos) na Engine Docker:
sudo docker ps -a
06 - Criar um container a partir da imagem base Debian, executando o

comando “cat /etc/issue.net” para capturar a versão do Debian:
sudo docker run debian cat /etc/issue.net
OBS: como não foi usado nenhum parâmetro opcional, o container irá
iniciar e, logo em seguida, parar
07 - Listar TODOS os containers (ativos e inativos) na Engine Docker:
sudo docker ps -a
08 - Criar um container a partir da imagem base Debian, usando os

parâmetros -itd e --name para definir um nome para o container (use
seu primeiro nome para o container):
sudo docker run -itd --name SEUNOME debian
OBS: os parâmetros -itd permitem que o container seja executado e

permaneça ativo em background (segundo plano)
09 - Listar os containers ativos (iniciados) na Engine Docker (observe

o campo NAME):
Página 3 de Docker
o campo NAME):
sudo docker ps
10 - Crie um container, de imagem do Ubuntu, onde será preciso

instalar o editor de texto "nano":
sudo docker run -it ubuntu bash
# sudo apt-get update && sudo apt-get install nano
OBS: observe que foi preciso iniciar um container solicitando o bash para
assim ter acesso ao shell do container
Página 4 de Docker
2-Administrando imagens - Orientação
sábado, 21 de novembro de 2020 21:23
Orientações sobre este módulo
Prezado aluno(a),
Seja bem-vindo(a) ao Módulo "Administração Básica de containers e imagens"
Neste módulo serão abordados os seguintes conteúdos:
Docker Lifecycle - o ciclo de vida de imagens e containers
Executar, parar e remover
É necessário obter mais informações
Interagir é preciso
Se interagir é preciso, fazer backup também
Pesquisar imagens também é fundamental
Posso administrar direto no navegador web?
Ao final desta seção, será preciso fazer as seguintes atividades:
Questionário - Administração Básica de containers e imagens
Mão na massa "Tendo controle de tudo"
Tarefa - "E se eu precisar recuperar um container?"
E, por fim, você:
Entenderá como funciona a dinâmica dos ciclos de vidas de containers e imagens
Conhecerá comandos Docker que permitem controlar os diversos estados de um container

(executado, parado, congelado e removido) e uma imagem
Conhecerá e aplicará comandos Docker que permitem coletar e monitorar informações sobre o
container, a imagem e a engine
Conhecerá maneiras para solicitar interação com containers
Aplicará recurso de backup, em arquivo tar, e recuperação de containers e imagens
Aprenderá o uso do docker search como forma de pesquisar imagens do Docker Hub via docker CLI
Administrará containers e imagens diretamente no navegador web
Desejo sucesso no curso!
Página 5 de Docker
2.1-Administração de imagens - Comandos
TRABALHANDO COM CONTAINERS
Listando container
docker ps
---------------------------------------------------------------------------------------------------------------------
Listando container em execução
docker ps -a
---------------------------------------------------------------------------------------------------------------------
Iniciando um container
docker start upbeat_swirles
---------------------------------------------------------------------------------------------------------------------
Congelando (Freezing) uma container
docker pause upbeat_swirles
---------------------------------------------------------------------------------------------------------------------
Descongelando (Freezing) um container
docker unpause upbeat_swirles
---------------------------------------------------------------------------------------------------------------------
Parando um container
docker stop upbeat_swirles
---------------------------------------------------------------------------------------------------------------------
Removendo um container
docker rm upbeat_swirles
---------------------------------------------------------------------------------------------------------------------
Removendo de força abrupta um container (Não recomendado) parar antes de remover
docker rm -f upbeat_swirles
---------------------------------------------------------------------------------------------------------------------
Removendo todos containers parados
docker container prune
---------------------------------------------------------------------------------------------------------------------
TRABALHANDO COM IMAGENS
Listando todas imagens

docker images
---------------------------------------------------------------------------------------------------------------------
Removendo uma imagem
docker rmi ubuntu:16.04
---------------------------------------------------------------------------------------------------------------------
Removendo todas imagens
docker image prune -a
---------------------------------------------------------------------------------------------------------------------
Baixando container e executando
docker run --name MARCELO --rm -itd ubuntu:16.04
---------------------------------------------------------------------------------------------------------------------
MONITORANDO CONTAINERS
Monitorando containers ativos

docker inspect MARCELO
---------------------------------------------------------------------------------------------------------------------
Inspecionando valores do container (Forma 1)
docker inspect MARCELO | grep Image
---------------------------------------------------------------------------------------------------------------------
Página 6 de Docker
---------------------------------------------------------------------------------------------------------------------
Inspecionando valores do container (Forma2)
docker inspect --format='{{.Config.Image}}' MARCELO
docker inspect --format='{{.NetworkSettings.Gateway}}' MARCELO
---------------------------------------------------------------------------------------------------------------------
Imagem de LOG para interação com ping em localhost
docker run --name LOGS -d busybox ping 127.0.0.1 -c 20
---------------------------------------------------------------------------------------------------------------------
Verificar os pings no container
docker logs LOGS
---------------------------------------------------------------------------------------------------------------------
Verificar os pings no container (Em tempo real) Similar ao tail
docker logs -f LOGS
---------------------------------------------------------------------------------------------------------------------
Verificar consumo dos containers (Estatisticas)
docker stats
---------------------------------------------------------------------------------------------------------------------
Verificar informações da arquitetura DOCKER
docker info
---------------------------------------------------------------------------------------------------------------------
Verificar informações de versão do server e client
docker version
---------------------------------------------------------------------------------------------------------------------
INTERAGINDO COM CONTAINERS
Interagindo no terminal do containers inativo

docker attach MARCELO
---------------------------------------------------------------------------------------------------------------------
Sair do container sem que pare o container (uso de teclas)
Ctrl+p+q
---------------------------------------------------------------------------------------------------------------------
Executar um comando em um container ativo
docker exec MARCELO ps aux
---------------------------------------------------------------------------------------------------------------------
Criar um arquivo em um container em backgroud
docker exec -d MARCELO touch /tmp/aula03
---------------------------------------------------------------------------------------------------------------------
Verificando o arquivo em background
docker exec MARCELO ls /tmp/
---------------------------------------------------------------------------------------------------------------------
Populando informação dentro do arquivo
docker exec MARCELO bash -c "echo 'aula03' >> /tmp/aula03"
---------------------------------------------------------------------------------------------------------------------
Acessando um comando interagindo com a bash
docker exec -it MARCELO bash
#OBS: Podendo usar o exit sem que pare o container

---------------------------------------------------------------------------------------------------------------------
Copiando o arquivo dentro do container para o host atual (Para fora do container)
docker cp MARCELO:/tmp/aula03 .
docker cp MARCELO:/tmp/aula03 ${PWD}
#OBS: Incrementando informação no arquivo

echo "Fora do container" >> aula03
---------------------------------------------------------------------------------------------------------------------
Copiando o arquivo dentro do container para o host atual (Para dentro do container)
docker cp aula03 MARCELO:/tmp/aula03
Página 7 de Docker
---------------------------------------------------------------------------------------------------------------------
FAZENDO BACKUP DE CONTAINER (EXPORTAR E IMPORTAR)
Criando backup do container com export (Compactando)

docker export MARCELO | gzip > export_container.tar.gz
---------------------------------------------------------------------------------------------------------------------
Deletando o container para testar o backup
docker rm -f MARCELO
---------------------------------------------------------------------------------------------------------------------
Voltando o container import (Decompactando)
zcat export_container.tar.gz | docker import - export_novo
#OBS: O container vira uma imagem

---------------------------------------------------------------------------------------------------------------------
Iniciando o container após descompactar do import
docker run -it --name MARCELO export_novo bash
---------------------------------------------------------------------------------------------------------------------
Iniciando o container lendo um arquivo e removendo em seguida
docker run --rm export_novo cat /tmp/aula03
---------------------------------------------------------------------------------------------------------------------
FAZENDO BACKUP DE IMAGEM
Criando backup de imagem com save (Compactando)
docker save export_novo | gzip -c > IMAGEM.tar.gz
---------------------------------------------------------------------------------------------------------------------
Removendo a imagem feito backup
docker rmi -f export_novo
---------------------------------------------------------------------------------------------------------------------
Voltando o Backup com LOAD (Descompactando)
docker load < IMAGEM.tar.gz
---------------------------------------------------------------------------------------------------------------------
LISTANDO IMAGENS DISPONIVEIS NO DOCKER HUB (VIA CLI)
Pesquisando uma imagen com sintaxe especifica

docker search openjdk
---------------------------------------------------------------------------------------------------------------------
Pesquisando uma imagen com sintaxe especifica (Somente officiais)
docker search --filter "is-official=true" java
---------------------------------------------------------------------------------------------------------------------
Página 8 de Docker
2.2-Mão na massa - "Tendo controle de tudo"
01 - Listar TODOS os containers da Docker Engine:
sudo docker ps -a
02 - Parar todos os containers criados e ativos:
sudo docker stop $(docker ps -q)
* Observe que foi preciso usar recursos shell Linux para listar todos os
containers ID ativos e passar como parâmetro para o comando "docker
stop"
03 - Iniciar algum container nomeado parado, anteriormente, que rode

em background por tempo indeterminado (observe o campo NAME e
a "razão de existir" do container):
sudo docker start [CONTAINER NAME]
* Caso não encontre nenhum container assim, crie um executando "sudo

docker run -itd --name SEUNOME ubuntu"
04 - Execute os seguintes comandos no container nomeado (observe

o campo NAME):
sudo docker exec -d [CONTAINER NAME] touch /tmp/maonamassa
sudo docker exec -d [CONTAINER NAME] bash -c "echo

'maonamassa' >> /tmp/maonamassa"
sudo docker exec -it [CONTAINER NAME] bash
cd /tmp && cat maonamassa
exit
* Observe as opções de "detach" e interações ao executar os comandos

usando docker exec
05 - Crie um arquivo txt no host e envie-o para um container ativo

(caso não exista, crie-o):
touch arquivo.txt
echo “arquivo de teste” >> arquivo.txt
sudo docker cp arquivo.txt CONTAINER:/tmp
Página 9 de Docker
06 - Faça modificações no arquivo enviado para o container e reenvie-
o para o host:
sudo docker attach CONTAINER
echo “dentro do container” >> /tmp/arquivo.txt
CTRL+P+Q
sudo docker cp CONTAINER:/tmp/arquivo.txt $(pwd)
* Observe que foi usado a opção "attach" para solicitar interação ao

container
07 - Parar container nomeado usado, anteriormente:
sudo docker stop CONTAINER_NAME
08 - Coletar informações de qual imagem esse container nomeado

está atrelado. Depois, removê-lo e remover imagem associada:
sudo docker inspect --format='{{.Config.Image}}' CONTAINER_NAME
OU
sudo docker inspect CONTAINER_NAME | grep Image
sudo docker rm CONTAINER_NAME
sudo docker rmi IMAGE_NAME
* Observe que para remover uma imagem Docker é preciso desassociá-la

de qualquer container primeiramente
09 - Remover TODOS os containers parados e imagens dissociadas:
sudo docker container prune
sudo docker image prune -a
* Observe a option -a, que indica "all" imagens paradas
10 - Pesquisar por imagem, no Docker Hub, usando palavra chave

"alpine":
sudo docker search --filter "is-official=true" --filter "stars=100" --no-trunc

alpine
* Observe o campo Description da base image.
11 - Criar um container, em background, a partir da imagem alpine, e
Página 10 de Docker
11 - Criar um container, em background, a partir da imagem alpine, e
baixar dentro do container, através do wget, imagem ISO do Debian
Linux Netinstall. Depois, monitorar os registros de logs do container
para saber quando o download terminará:
sudo docker run -itd --rm --name wget alpine wget -c

http://debian.c3sl.ufpr.br/debian-cd/10.6.0/amd64/iso-cd/debian-10.6.0-amd64-netinst.iso
http://debian.c3sl.ufpr.br/debian-cd/9.8.0/amd64/iso-cd/debian-9.8.0-
amd64-netinst.iso
sudo docker logs -f wget
* Observe ao término do download (via wget) que o container será

removido, pois a option '--rm' foi setada
De <https://www.udemy.com/course/docker-introducao-a-administracao-de-containers/learn/lecture/13770086
#questions>
2.3-Mão na massa - "Recuperar um container"
Num cenário hipotético, um colega de trabalho precisou interromper suas atividades

sobre determinada aplicação que rodava em container Docker.
Mesmo sabendo que um container é um elemento volátil, foi preciso salvar um arquivo
importante dentro do container em execução. Mas, você, que já entende um pouco
desse cenário, solicitou a ele que exportasse o container para formato de
arquivo .tar.gz e o enviasse para que você o recuperasse e copiasse o arquivo salvo no
container para seu computador, para, assim, seguir todos os procedimentos necessários
para dar continuidade ao trabalho.
Diante disso, o objetivo dessa tarefa é recuperar o arquivo contido no container, em
questão, e seguir as orientações do mesmo.
INFORMAÇÕES IMPORTANTES
• Comando usado para exportar container: sudo docker export container | gzip >
CONTAINER.tar.gz
• Link para download do container exportado em
formato .tar.gz: http://bit.ly/CONTAINER_EXPORTADO (somente no browser)
• Local do arquivo, dentro do container: /tmp/orientacoes.txt
• Comando para importar container: zcat CONTAINER.tar.gz | sudo docker import -
novo_nome_container
Perguntas dessa tarefa
AÇÃO: Importe o container baixado e execute-o em background.
PERGUNTA: Quais procedimentos foram feitos para importar e executar, em
background, o container baixado?
RESPOSTA: Foi baixado direto do browser e importado para dentro da VM via WINSCP
Para importar e executar:
docker run --name CONTAINER -itd novo_nome_container bash
AÇÃO: Copie o arquivo do container (/tmp/orientacoes.txt) para seu computador.
PERGUNTA: Qual procedimento foi feito para copiar o arquivo do container para seu
computador? E qual é seu conteúdo?
RESPOSTA: Foi realizado a copia do arquivo com o comando abaixo
docker cp CONTAINER /tmp/orientacoes.txt ${PWD}
AÇÃO: Siga as orientações do arquivo, contido no container, e execute-as em
sequência.
root@ubuntu:~# cat orientacoes.txt
# 1 - Iniciar 2 containers, com nomes cont_1, cont_2 e options "-itd", de imagem alpine
e debian, respectivamente;
docker search alpine
docker pull alpine
docker pull debian
docker search --filter "is-official=true" Debian
docker run --name count_1 -itd alpine
docker run --name count_2 -itd debian
# 2 - Verificar as estatasticas de consumo dos containers iniciados, anterioremente;
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM %
NET I/O BLOCK I/O PIDS
49db4c343534 count_2 0.00% 456KiB / 1.953GiB 0.02% 648B
/ 0B 0B / 0B 1
e3a9e707f003 count_1 0.00% 132KiB / 1.953GiB 0.01% 648B /
0B 0B / 0B 1
8d642fbd83cd CONTAINER 0.00% 412KiB / 1.953GiB 0.02%
828B / 0B 0B / 8.19kB 1
# 3 - Inspecione o container de imagem alpine;
docker
inspect al...
# 4 - Pare e remova os 2 containers criados, anteriormente;

docker stop count_1
docker stop count_2
docker rm count_1
docker rm count_2
PERGUNTA: Dada orientações contidas no arquivo, mostre quais foram os comandos
usados para executá-las?
AÇÃO: Sabendo que é possível executar um comando num container já executado,
execute o comando cat para ler o arquivo do container sem precisar copiá-lo para seu
computador e solicitar interação com o container.
PERGUNTA: Qual comando e sintaxe completa para ler o conteúdo do arquivo contido
no container sem precisar copiá-lo para seu computador e solicitar interação com o
container?
docker exec CONTAINER cat /tmp/orientacoes.txt
3-Object: Networking - Orientação
Seja bem-vindo(a) ao Módulo "Docker Object - Networking"
Docker Networking - todo container pode receber um IP
Bridge Network - rede padrão de comunicação
Bridge Network - acesso externo ao container com uso de mapeamento de portas
Host Networking - sem "ponte" entre host e o container
Outros networks drivers - none, macvlan e overlay
Questionário - É preciso entender da rede também
Mão na massa - "Meu primeiro container web"
Tarefa - "Migramos o banco de dados para container"
E, por fim, você:
Conhecerá os recursos que permitem que um container tenha conectividade com outros e o "resto
do mundo"
Entenderá como funciona a rede padrão Docker que concede conectividade a todos os containers
criados
Entenderá o mapeamento de portas dos containers para conceder comunicação externa. Primeiras
aplicações poderrão ser criadas
Conhecerá outro meio de comunicação que usa a mesma pilha de conexão do host com os
containers
Conhecerá outros networks drivers disponíveis
3.1-Object: Networking - Comandos
TRABALHANDO COM REDES NO DOCKER
Listando redes no docker

docker network ls
---------------------------------------------------------------------------------------------------------------------
Inspecionar bridges
docker network inspect bridges
---------------------------------------------------------------------------------------------------------------------
Verificando ip no linux
Ip a
---------------------------------------------------------------------------------------------------------------------
Inspecionar redes no container
docker exec c1 ip a
---------------------------------------------------------------------------------------------------------------------
Inspecionar redes no container especifico
docker inspect c1 | grep IP
---------------------------------------------------------------------------------------------------------------------
Mapeamento de portas (Manual)
docker run -d --name c1_apache -p 9090:80 httpd
docker run -d --name c1_apache -p 9090:80 httpd
OBS: Subir um container e mapear da porta 9090 do host para porta 80 do container servidor
apache
---------------------------------------------------------------------------------------------------------------------
Mapeamento de portas (Automatica)
docker run -d --name c2_apache -P httpd
---------------------------------------------------------------------------------------------------------------------
Verificando portas no Docker
docker port c2_apache
docker ps
---------------------------------------------------------------------------------------------------------------------
Subindo container em modo host sem compartilhar rede
docker run -itd --net host --name c1_busybox busybox
docker run -d --net host --name c4_apache httpd
3.2-Mão na massa - "Meu primeiro container web"
domingo, 22 de novembro de 2020 19:17
Mão na massa - "Meu primeiro container web"
01 - No host, exibir e verificar as interfaces de redes criadas:

sudo ip a
* Observe as interfaces docker0 e veth, caso tenha algum container ativo. Além disso, encontre o
segmento de rede PRIVADA criada na instalação da Docker Engine
02 - Verificar se algum container está ativo (iniciado), caso contrário iniciar e capturar o endereço
IP que ele recebeu:
sudo docker ps
sudo docker run -itd --name [CONTAINER NAME] busybox
sudo docker inspect [CONTAINER NAME] | grep IP
* Observe que o endereço IP atribuído a esse container será do mesmo segmento da interface
bridge “docker0”
03 - Acessar um terminal bash no container com seu nome:
sudo docker exec -it [CONTAINER NAME] bash
04 - Verificar a conectividade com o “mundo exterior” pingando para algum host da internet:
ping 8.8.8.8
ping google.com
exit
05 - Ou diretamente, pelo comando “docker exec”:

sudo docker exec -it [CONTAINER NAME] ping google.com
06 - Iniciar um container que ofereça uma aplicação web, com mapeamento de portas manual
sudo docker run -itd --name web_80 -p 9090:80 httpd
* Observe o parâmetro -p
* Depois de iniciado, prossiga para o browser do seu computador e acesse http://localhost:9090
Estava utilizando maquina qemu dentro do EVENG
07 - Iniciar um container que ofereça uma aplicação web, com mapeamento de portas automático
sudo docker run -itd --name web_random -P httpd
* Observe o parâmetro -P
* Mapeamento automático gera um porta aleatória. Para descobri-la, execute:
sudo docker port [CONTAINER_NAME]
* Depois de iniciado e descoberto a porta, prossiga para o browser do seu computador e acesse
http://localhost:PORTA
08 - Criar container web no modo de conexão do tipo "host"

sudo docker run -itd --net host --name S1_host nginx
* Depois de iniciado, prossiga para o browser do seu computador e acesse http://localhost
* Observe a ausência dos parâmetros -p e -P. No modo "host" a pilha de socket de host se iguala aos
containers partícipes dela. Não podendo ter essa porta em uso no host.
09 - Criar container de banco mysql:

sudo docker run --name mysql --env MYSQL_ROOT_PASSWORD=minhasenha -d mysql
sudo docker exec -it mysql bash
# msyql -u root -p
Informar senha passada na variável de ambiente "MYSQL_ROOT_PASSWORD" para ter acesso a
console admin do mysql.
* Observe a presença de uma nova option do docker run, apresentada como "--env" ou "-e". Ela é
responsável por receber valor de uma variável de ambiente prevista na imagem a ser utilizada. Ou
seja, quem desenvolveu a imagem mysql decidiu que quem for usar teria que informar esse ou
outros valores, em tempo de execução do container, para cada variável invocada. Algumas são
obrigatórias, como no caso da MYSQL_ROOT_PASSWORD - consulte mais informações na
documentação oficial da imagem.
De <https://www.udemy.com/course/docker-introducao-a-administracao-de-containers/learn/lecture/13950536
#overview>
3.3-Mão na massa - Migrar Banco de dados
segunda-feira, 23 de novembro de 2020 10:03
Instruções da tarefa
45 minutos para concluir
101 soluções do aluno
Num cenário hipotético, as exigências do seu cargo estão aumentando. Agora, a sua equipe decidiu
iniciar um processo de adoção de alguns serviços de rede em containers. Dentre diversas outras
opções, você foi incumbido a homologar o uso de base de dados Postgresql em container.
Diante disso, o objetivo dessa tarefa é que você inicie um container de servidor Postgresql em
modo de conexão bridge padrão. Depois, através de um único cliente psql, você use outro
container para acessar o container servidor e criar um banco de dados de teste. Por fim, através do
cliente desktop pgAdmin validar esse teste.
• Imagem para uso de container servidor Postgresql: postgres (consulte mais em
https://hub.docker.com/_/postgres/)
• Imagem para uso de container cliente Postgresql: governmentpaas/psql (consulte mais em
https://hub.docker.com/r/governmentpaas/psql)
• Sintaxe de comando de acesso, via psql cliente, a base de dados criada: psql -h
<IP_CONTAINER_SERVER> -U postgres --password
• Sintaxe de comando SQL para criação de banco de dados: CREATE DATABASE teste;
• Porta de conexão do container servidor Postgresql: 5432
• Download de cliente pgAdmin: https://www.pgadmin.org/
VARIÁVEIS DE AMBIENTES EM TEMPO DE EXECUÇÃO NO DOCKER
No processo de criação das imagens (build), muitos desenvolvedores decidem usar os benefícios de
variáveis de ambientes, amplamentes utilizadas em diversas linguagens e plataformas de
programação. Essa técnica se deve ao fato de manter seguro e eficiente o uso de informações
sensíveis da sua aplicação que não podem (e devem) estar salvar em imagem (elemento estático e
genérico). Por exemplo, senhas, usuários e/ou informações sensíveis importantes.
Assim, é de respondibilidade de quem cria o container, a partir da imagem, informar em tempo de
execução as variáveis de ambientes previstas na imagem - para informações à cerca de quais
existem (e se existem) em cada imagem é recomendado consultar sempre a documentação oficial,
de desenvolvimento dela no Docker Hub ou GitHub disponibilizado, antes de criar seu container.
No Docker, essas variáveis são usadas através da option, no docker run, --env ou -e.
Exemplo de uso (teste esse comando no seu ambiente de estudos):
1. $ docker run --rm --env VAR1=value1 -e VAR2=value2 ubuntu env | grep VAR
2. VAR1=value1
3. VAR2=value2
Mais informações sobre variáveis de ambientes no Docker:
https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---
env---env-file
AÇÃO - criar e iniciar, em background, container servidor PSQL na network default padrão,
mapeando a porta do host com o container na 3333, usando imagem "postgres" sugerida.
PERGUNTA - Qual sintaxe de comando completo para criação de container de servidor Postgresql
com essas características?
AÇÃO - criar banco de dados "teste" no container servidor PSQL usando um container psql cliente
de imagem "governmentpaas/psql" sugerida.
de imagem "governmentpaas/psql" sugerida.
$docker run --name postgres -e POSTGRES_PASSWORD=minhasenha -d -p 3333:5432 postgres
PERGUNTA - Quais os passos você usou para ter acesso ao container servidor, via outro container
cliente, e, logo em seguida, criar base de dados "teste" nele?
AÇÃO - baixar e usar cliente gráfico pgAdmin no seu host, acessar servidor container PSQL e
visualizar banco de dados "teste" criado, anteriormente.
Para descobrir o IP do servisor Postgres:
$docker inspect postgres | grep IP
Para conectar o psql ao servidor Postgres:
docker exec -it psql psql -h 172.17.0.5 -U postgres --password
Para criar o banco de dados:
CREATE DATABASE teste;
PERGUNTA - Quais parâmetros de rede (host, port, username, password) você usou para ter
acesso e visualização dos banco criados nesse container servidor PSQL? Envie prints da tela com as
configurações de conexão feitas e listagem de bancos desse container servidor PSQL.
De <https://www.udemy.com/course/docker-introducao-a-administracao-de-
containers/learn/practice/1099882/introduction#overview>
4-Object: Volumes
segunda-feira, 7 de dezembro de 2020 20:21
4.1-Object: Volumes: Comandos
Comandos para verificar o volume dos storages
ls /var/lib/docker
du -sh /var/lib/docker/image/overlay2
docker info
-------------------------------------------------------------------
Subindo um container e criando arquivo dentro do container para viasualizar espaço no storage virtual
docker run -itd --name teste ubuntu:16.04
docker ps -s
----------------------------------------------------------------------------------------------------------------------------- -------------------------------------------
root@ubuntu:~# docker ps -s
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES SIZE
101e17288c3e ubuntu:16.04 "/bin/bash" About a minute ago Up About a minute teste 0B (virtual 131MB)
----------------------------------------------------------------------------------------------------------------------------- -------------------------------------------
Inserindo conteudo
docker exec -it teste touch /tmp/arquivo_teste
docker exec -it teste bash
echo "dados" >> /tmp/arquivo_teste
exit
----------------------------------------------------------------------------------------------------------------------------- -------------------------------------------
root@ubuntu:~# docker ps -s
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES SIZE
101e17288c3e ubuntu:16.04 "/bin/bash" 2 minutes ago Up 2 minutes teste 47B (virtual 131MB)
root@ubuntu:~#
----------------------------------------------------------------------------------------------------------------------------- -------------------------------------------
4.2-Object Volumes: BIND MOUNT
Mapeando diretórios
Sobe um container apache mapeando dentro do host hospedeiro
VERMELHO: Sintaxe mapeamento

AZUL: Host Hospedeiro
VERDE: Container
docker run -itd --name apache -p 9090:80 -v /home/root/site:/usr/local/apache2/htdocs httpd:2.4
Criar arquivo index dentro do Container

docker exec -it apache bash
touch index.html
exit
Verificar arquivo dentro do host hospedeiro

ls /home/root/site
echo "<h1>MEU PRIMEIRO CONTAINER<\h1>" >>index.html
curl http://localhost:9090
--------------------------------------------------------------------------
docker run -itd --name apache3 -p 9090:80 -v /home/root/site:/usr/local/apache2/htdocs -v /etc/localtime:/etc/localtime:ro httpd:2.4
4.3-Object Volume: ON RAM
Criando uma persistência na memória ram
docker run -itd --name tmpfs --tmpfs /tmp busybox
--------------------------------------------------------------------------------------------------------------------------
root@ubuntu:~# docker exec tmpfs df -h
Filesystem Size Used Available Use% Mounted on
overlay 18.1G 4.2G 13.0G 24% /
tmpfs 64.0M 0 64.0M 0% /dev
tmpfs 1000.1M 0 1000.1M 0% /sys/fs/cgroup
shm 64.0M 0 64.0M 0% /dev/shm
tmpfs 1000.1M 0 1000.1M 0% /tmp
/dev/mapper/ubuntu--vg-root
18.1G 4.2G 13.0G 24% /etc/resolv.conf
18.1G 4.2G 13.0G 24% /etc/hostname
18.1G 4.2G 13.0G 24% /etc/hosts
tmpfs 1000.1M 0 1000.1M 0% /proc/acpi
tmpfs 64.0M 0 64.0M 0% /proc/kcore
tmpfs 64.0M 0 64.0M 0% /proc/keys
tmpfs 64.0M 0 64.0M 0% /proc/timer_list
tmpfs 64.0M 0 64.0M 0% /proc/timer_stats
tmpfs 64.0M 0 64.0M 0% /proc/sched_debug
tmpfs 1000.1M 0 1000.1M 0% /proc/scsi
tmpfs 1000.1M 0 1000.1M 0% /sys/firmware
root@ubuntu:~#
--------------------------------------------------------------------------------------------------------------------------
Testando a criação de um arquivo em memória ram na pasta tmp de 1000k em seguida ele remove para apresentar o tempo
docker exec -it tmpfs dd if=/dev/zero of=/tmp/output bs=1k count=1000k; rm -f /tmp/output
--------------------------------------------------------------------------------------------------------------------------
root@ubuntu:~# docker exec -it tmpfs dd if=/dev/zero of=/tmp/output bs=1k count=1000k; rm -f /tmp/output
1024000+0 records in
1024000+0 records out
1048576000 bytes (1000.0MB) copied, 9.937325 seconds, 100.6MB/s
root@ubuntu:~#
--------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------
Testando a criação de um arquivo em Hardisk na pasta output de 1000k em seguida ele remove para apresentar o tempo
docker exec -it tmpfs dd if=/dev/zero of=/output bs=1k count=1000k; rm -f /output
--------------------------------------------------------------------------------------------------------------------------
root@ubuntu:~# docker exec -it tmpfs dd if=/dev/zero of=/output bs=1k count=1000k; rm -f /output
1024000+0 records in
1024000+0 records out
1048576000 bytes (1000.0MB) copied, 13.604728 seconds, 73.5MB/s
root@ubuntu:~#
--------------------------------------------------------------------------------------------------------------------------
4.4-Object Volumes: Volume
Criar um volume primeiro

docker volume create vol-web
--------------------------------------------------------------------------------
docker volume ls
Mapeando tanto BIND MOUNT quanto VOLUME
docker run -d --name apache_vol -p 9091:80 -v /etc/localtime:/etc/localtime:ro -v vol-web:/usr/local/apache2/htdocs httpd:2.
----------------------------------------------------------------------------------------------------------------------------- -----------------------------------
root@ubuntu:~# curl http://localhost:9091
<html><body><h1>It works!</h1></body></html>
root@ubuntu:~#
----------------------------------------------------------------------------------------------------------------------------- -----------------------------------
Copiar o arquivo index.html para o volume do apache

docker cp /home/root/site/index.html apache_vol:/usr/local/apache2/htdoc
--------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------- -----------------------------------
root@ubuntu:~# curl http://localhost:9091
<h1>MEU PRIMEIRO CONTAINER<\h1>
root@ubuntu:~#
----------------------------------------------------------------------------------------------------------------------------- -----------------------------------
Fazendo modificação do arquivo index.html para o volume do apache
cd /home/root/site
docker cp apache_vol:/usr/local/apache2/htdocs .
ls
echo "<hr/> <h2> Subtitulo" >> index.html
docker cp index.html apache_vol:/usr/local/apache2/htdocs
----------------------------------------------------------------------------------------------------------------------------- -----------------------------------
root@ubuntu:/home/root/site# curl http://localhost:9091
root@ubuntu:/home/root/site# curl http://localhost:9091
<hr/> <h2> Subtitulo
root@ubuntu:/home/root/site#
----------------------------------------------------------------------------------------------------------------------------- ----------------------------------
Abrindo diretamente do volume

ls /var/lib/docker/volumes
----------------------------------------------------------------------------------------------------------------------------- ----------------------------------
root@ubuntu:/home/root/site# cat /var/lib/docker/volumes/vol-web/_data/index.html
<hr/> <h2> Subtitulo
root@ubuntu:/home/root/site#
----------------------------------------------------------------------------------------------------------------------------- ----------------------------------
4.5-Object Volume: Mão na massa
Mão na massa - "Criando aplicação com dados persistidos"

01 - Criar uma pasta para aplicação web:
mkdir ~/docker/site
* Você deve armazenar todos os arquivos do seu site nessa pasta!
02 - Criar um arquivo básico index.html de exemplo:
<h1>Minha primeira página web </h1>
03 - Utilizar o primeiro método de mapeamento de volumes Docker (método "host volume"):

sudo docker run -d --name web_pasta -v
~/docker/site:/usr/local/apache2/htdocs -P httpd
sudo docker port web_pasta
* Observe que o 'docker port' é utilizado para descobrir qual porta foi liberada no host automaticamente; já que foi usado o parâmetro '-P'
04 - Acessar o navegador web no endereço http://localhost:[PORTA]:
* Observe que o arquivo index.html será carregado. Fique a vontade para colocar quaisquer arquivos html, css ou js na pasta ~/docker/site. Depois, veja o
resultado atualizando a página!
05 - Para usar Docker Volume crie seu primeiro volume:
sudo docker volume create --name datastore
06 - Crie uma aplicação que use esse volume:
sudo docker run --name containervolume -v datastore:/usr/local/apache2/htdocs -p 9090:80 httpd
* Acessar o navegador web no endereço http://localhost:9090 e veja que o arquivo index.html da imagem será mantido, apresentando o texto "It works!".
Diferentemente do modo anterior, os dados com uso de volumes não são "sobrescritos"
07 - Copiar arquivo index.html para dentro do volume usando o 'docker cp':
sudo docker cp ~/docker/site/index.html containervolume:/usr/local/apache2/htdocs
* Observe que ao enviar dados para a pasta do container mapeado com o volume, consequentemente, esses dados serão preservadosno volume.
* Depois, prossiga para o browser do seu computador e acesse http://localhost:9090 novamente e veja o novo arquivo index.html sendo carregado
* Caso prefira, você poderá copiar todos os arquivos do diretório /docker/site através do uso do "." (ponto) ao final da barra invertida (/):
sudo docker cp ~/docker/site/. containervolume:/usr/local/apache2/htdocs
08 - Remover container:
sudo docker stop containervolume
sudo docker rm containervolume
09 - Inicie outro container web com o mesmo volume criado, anteriormente:

sudo docker run --name containervolume_2 -v datastore:/usr/local/apache2/htdocs -p 9091:80 httpd
* Acessar o navegador web no endereço http://localhost:9091 e veja que o arquivo index.html enviado está mantido, pois foi persistido em volume fora do
ciclo de vida do container .
10 - Listar e remover volume:
sudo docker volume ls
sudo docker stop containervolume_2
sudo docker rm containervolume_2
sudo docker volume rm datastore
* Observe que primeiro deve ser parado e removido o container de aplicação que usa esse volume. Depois, assim, remover o volumedocker
4.6-Tarefa: Save the data
quarta-feira, 9 de dezembro de 2020 21:37
Tarefa tem como objetivo mostrar os benefícios de se manter dados persistidos externamente ao
ciclo de vida dos containers. Aplicando em um cenário onde 3 containers acessam volume
compartilhado e rotina de backup definida.
Para um maior controle dos dados manipulados em aplicações executadas via containers Docker é
sabido que você deve primar pela persistência de dados, mantida externamente ao ciclo de vida do
container. Diante disso, você recebeu a tarefa de criar e salvaguardar todos os dados de uma
aplicação web.
A equipe de desenvolvimento ficou de enviar todos os arquivos de front (HTML, CSS, JS) para você
iniciar, por container, um web server estático. E a fim de manter salvos todos esses dados do web
site em disco/partição remota, você, também, deve definir meios para serem feitas cópias de
seguranças (backup) desses dados via formato tape (tar).
Para isso, a equipe de infraestrutura disponibilizou, no ambiente virtualizado, a ser usado, 2
partições, em LUNs distintas na rede SAN da empresa:
• uma (1) para os dados e;
• uma (1) para backup;
Sendo assim, você deve criar 1 volume de dados (docker volume) numa partição e criar 3 containers
web mapeando-os para o mesmo volume, criado anteriormente. E, logo após disponibilizar o
serviço web solicitado, você deve executar uma única rotina, manual, de backup, para formato tape
(tar) na outra partição, destinada para esse fim. Ao fim, você deverá ter 3 containers executados,
disponibilizando a mesma aplicação web, em portas de conexões distintas (80,81,82, por exemplo),
e um único volume mapeado para eles.
• Sugestões de imagens para disponibilizar web site estático (livre para escolher): httpd
(consulte mais em https://hub.docker.com/_/httpd) ou nginx (consulte mais em
https://hub.docker.com/_/nginx)
• Arquivos de front enviados pela equipe de desenvolvimento: http://bit.ly/FRONT_SITE (fonte
https://startbootstrap.com/themes/stylish-portfolio/)
• Partições criadas pela equipe de infraestrutura:
1. /var/lib/docker - DADOS
2. /mnt/docker/backup - BACKUP
• Comando para rotina de backup: tar cvf /mnt/docker/backup/arquivobackup.tar
{DIR_CONTAINER_MAPEADO_VOLUME}
• Imagem para container de rotina de backup: busybox
Quais comandos usados para criar e listar o volume compartilhado, respectivamente?
Quais comandos usados para criar os 3 containers web, com execução em background, que devem
acessar o volume compartilhado?
Dado a necessidade de atualizar o volume compartilhado, com os arquivos de Front baixados, qual
comando usado para enviar esses arquivos para o volume?
Por motivo de segurança, é recomendado que execute uma rotina de backup, logo após algumas
mudanças que podem serem feitas nos dados do volume compartilhado.
Sendo assim, qual comando usado para criar um container temporário (com option --rm), imagem
busybox, responsável por mapear volume compartilhado e diretório em partição de backup no
host, e executar, dentro do container, comando para gerar arquivobackup.tar diretamente na
partição de backup, criada pela equipe de infraestrutura?
Envie os prints das telas de acesso, no browser, de cada web site estático criado, em portas
distintas (80,81,82, por exemplo)
Fazer download dos arquivos de recursos
startbootstr
ap-stylish...
startbootstr
ap-stylish...
startbootstr
ap-stylish...
RESPOSTA
Quais comandos usados para criar e listar o volume compartilhado, respectivamente?
Lembre-se do "docker volume"
Quais comandos usados para criar os 3 containers web, com execução em background, que devem
acessar o volume compartilhado?
Consulte as imagens oficiais sugeridas (https://hub.docker.com/_/nginx e https://hub.docker.com/
_/httpd) e obtenha informações, principalmente, de qual pasta do container, responsável por
manter arquvios do web site, deve ser persistida.
Dado a necessidade de atualizar o volume compartilhado, com os arquivos de Front baixados, qual
comando usado para enviar esses arquivos para o volume?
Lembre-se do "docker cp" e que, como o volume é compartilhado, é necessário enviar para diretório
mapeado de apenas um container web criado :)
DICA: para copiar diretórios, usando o docker cp, você deve usar o artifício do "." (ponto):
Ex1: copiar um arquivo - docker cp ./src/build/index.html ContainerName:/app/
Ex2: copiar todos os arquivos do diretório - docker cp ./src/build/. ContainerName:/app/
Por motivo de segurança, é recomendado que execute uma rotina de backup, logo após algumas
mudanças que podem serem feitas nos dados do volume compartilhado.
Sendo assim, qual comando usado para criar um container temporário (com option --rm), imagem
busybox, responsável por mapear volume compartilhado e diretório em partição de backup no
host, e executar, dentro do container, comando para gerar arquivobackup.tar diretamente na
partição de backup, criada pela equipe de infraestrutura?
A dica é saber que você precisa mapear dois de tipos de persistências num container temporário. Ou
seja:
1. um mapeamento, do tipo bind mount, no diretório de partição de backup do host
( /mnt/docker/backup ) com um diretório temporário do container (/tmp por exemplo)
2. um mapeamento, do tipo docker volume, com o volume compartilhado (criado,
2. um mapeamento, do tipo docker volume, com o volume compartilhado (criado,
anteriormente, por você) com outro diretório temporário do container (/root por exemplo)
Por fim, executar, dentro do container, em tempo de execução do container, o comando para gerar
arquivobackup.tar:
tar cvf /tmp/arquivobackup.tar /root
Envie os prints das telas de acesso, no browser, de cada web site estático criado, em portas
distintas (80,81,82, por exemplo)
No browser, capture os prints do acesso do site em cada porta de conexão estabelecida
5-Comunicação: Entre containers
Prezado aluno(a),
Seja bem-vindo(a) ao Módulo "Comunicação entre containers - uma abordagem para microserviços"

• Containers e Microserviços - uma nova abordagem
• User-defined bridge network - rede bridge definida pelo usuário
• Containers Links - método legado para comunicação
• Questionário - Comunicação entre containers
• Mão na massa - "Mútiplos containers conectados"
• Tarefa - "Containers conectados"
E, por fim, você:
• Compreenderá uma arquitetura utilizando Microserviços e uma arquitetura Monolítica;
• Criará redes próprias, no modo bridge network, para oferecer aplicações mais seguras e
flexíveis;
• Conhecerá o método mais simples, legado e obsoleto para conectar containers;
5.1-Comunicação: Containers e microserviços
5.2-Comunicação: User defined bridge
Criando uma rede

docker network create --subnet 10.0.0.0/24 busybox-net
------------------------------------------------------------------------------------------------------
Verificando a rede
docker network ls
------------------------------------------------------------------------------------------------------
Inspecionar a rede
docker network inspect busybox-net
------------------------------------------------------------------------------------------------------
Criar container em backgroud usando a rede criada
docker run -itd --name c1 --net busybox-net busybox
------------------------------------------------------------------------------------------------------
docker ps
------------------------------------------------------------------------------------------------------
Criando container configurando ip fixo e mapeando porta usando o nginx
docker run -itd --name c2 --net --ip 10.0.0.254 -p 9090:80 nginx
------------------------------------------------------------------------------------------------------
Pingar o ip do container do nginx usando busybox (c1 pingar c2)
docker exec -it c1 ping 10.0.0.254
------------------------------------------------------------------------------------------------------
Pingar com a resolução de nome DNS entre containers
docker exec -it c1 ping c2
------------------------------------------------------------------------------------------------------
Testar telnet do c1 para c2 na porta 80 (Imagem busybox)
docker exec -it c1 telnet c2 80
------------------------------------------------------------------------------------------------------
Criar um container c3 na bridge padrão fora da rede do c1 e c2
docker run -itd --name c3 busybox
------------------------------------------------------------------------------------------------------
docker os
------------------------------------------------------------------------------------------------------
Testar ping do c3 para o c2
docker exec -it c3 ping 10.0.0.254
docker exec -it c3 ping c2
docker exec -it c3 telnet c2 80
------------------------------------------------------------------------------------------------------
Criar uma rede propria wordpress
docker network create rede-wordpress
docker network ls
ip a
------------------------------------------------------------------------------------------------------
Criar um container DB com a rede wordpress
docker run --name wp-db -e MYSQL_ROOT_PASSWORD=mysql -d --net rede-wordpress mysql:5.4
------------------------------------------------------------------------------------------------------
Criar container wordpress para se conectar no banco de dados DB-WP
docker run --name wp -e WORDPRESS_DB_HOST=wp-db -e WORDPRESS_DB_USER=root -e WORDPRESS_DB_PASSWORD=mysql -p 8080:80 -d --net rede-wordpress wordpress
------------------------------------------------------------------------------------------------------
5.3-Comunicação: Container Links
Criando container L1 busybox

docker run -itd --name l1 busybox
------------------------------------------------------------------------
------------------------------------------------------------------------
Fazer link entre L2 e L1
Linkalias = apelido
docker run itd --name l2 --link l1:linkalias busybox

------------------------------------------------------------------------
------------------------------------------------------------------------
Conectar entre os tres container
docker run -itd --name l3 --link l1:meul1 l2:meul2 busybox
------------------------------------------------------------------------
docker ps
------------------------------------------------------------------------
Teste de ping do l2 par al1 (sucesso)
docker exec -it l2 ping l1
------------------------------------------------------------------------
Teste de ping do l1 par al2 (Falha )
A falha é devido a conexão link foi feita do L2 para L1 e não L1 para L2 (Não full duiplex)
docker exec -it l2 ping l1
------------------------------------------------------------------------
EXEMPLO WORDPRESS
Subir um container de banco de dados Mysql
docker run -d --name db1 -e MYSQL_ROOT_PASSWORD=mysql mysql:5.7
------------------------------------------------------------------------
Conectar um container no bancdo de dados usando a imagem wordpress
docker run -d --name wp1 --link db1:meudb -p 8090:80 wordpress
------------------------------------------------------------------------
5.4-Mão na Massa - Mútiplos containers conectados
Mão na massa - "Mútiplos containers conectados"

01 - Criar um container ubuntu com nome ubuntu1:
sudo docker run -itd --name ubuntu1 ubuntu:18.04

* Observe que esse container rodará em segundo plano
02 - Criar um segundo container fazendo 'linking' com o primeiro:
sudo docker run -itd --name ubuntu2 --link ubuntu1:cont1 ubuntu:18.04

* Observe que o container de destino foi "apelidado" de cont1.
03 - Acessar o terminal do segundo container
sudo docker exec -it ubuntu2 bash

# ping cont1
# ping ubuntu1
# exit
* Observe que o comando 'ping' deve ser executado dentro do container. E 'cont1' representa o container de nome ubuntu1.
sudo docker exec -it ubuntu1 bash

# ping ubuntu2
# exit
* Observe que o comando 'ping' não tem resposta para o container ubuntu2, pois o link é um meio de comunicação de origem e destino, não vice-versa.
04 - Verifique os arquivo hosts do container de origem (ubuntu2):
sudo docker exec ubuntu2 cat /etc/hosts

* Observe que o resultado do comando exibirá o ip do container ubuntu1 associado ao nome 'cont1' - seu apelido
05 - Crie uma rede bridge "própria":
sudo docker network create minharede

* Ao criar esse rede você poderá colocar todos os containers que desejar manter conexões
06 - Visualize a criação da rede:
sudo docker network ls

sudo docker network inspect minharede
* Veja que o comando network ls exibe todas as redes existentes e o comando network inspect detalhe as informações da rede criada
07 - Crie dois containers de imagens debian e coloque eles na rede criada:
docker run -itd --name debian1 --net minharede debian

docker run -itd --name debian2 --net minharede debian
08 - Acesse o container de nome ubuntu1 e teste uma conexão com o container debian2:
docker exec -it ubuntu1 bash

# ping debian2
# exit
* Observe que você não conseguiu êxito no ping. Porque o container ubuntu1 não faz parte da rede criada
09 - Acesse o container de nome debian1 e teste uma conexão com o container debian2:
docker exec -it debian1 bash

# ping debian2
# exit
* Observe que dessa vez conseguiu êxito no ping. Porque o container debian1 faz parte da rede criada
10 - Remova a rede e containers criados
sudo docker stop ubuntu1

sudo docker stop ubuntu2
sudo docker stop debian1
sudo docker stop debian2
sudo docker rm ubuntu1
sudo docker rm ubuntu2
sudo docker rm debian1
sudo docker rm debian2
sudo docker network rm minharede
sudo docker network rm minharede
De <https://www.udemy.com/course/docker-introducao-a-administracao-de-containers/learn/lecture/14210168#overview>
5.5-Tarefa-Containers conectados
Essa tarefa tem como objetivo criar e administrar múltiplas redes de comunicações entre os containers para criar aplicação ba seada em microserviços.
Diante do conhecimento adquirido até aqui, você é capaz, mesmo em cenário não propício para isso (ambiente local single -host), disponibilizar um serviço simples
de balanceamento de carga (load balancer) entre duas aplicações web similares, a partir de containers interconectados por redes bridges definidas pelo usuário .
Para garantir a natureza de microserviços, você deve criar um container para cada finalidade:
• 1 container para o load balancer com nome "lb" + 1 diretório mapeado para arquivo de configuração
• 1 container web com nome "web1" + 1 volume mapeado para arquivos de FRONT do site
• 1 container web com nome "web2" + 1 volume mapeado para arquivos de FRONT do site
Onde, somente o container "load balancer" terá suas conexões na porta web 80 liberada, externamente. O restante dos container s (web1 e web2), somente,
terão acesso permitido a partir do container balanceador (vide imagem superior de exemplo).
Assim, para garantir as interconexões seguras entre os containers, você deverá criar, adicionalmente, 1 rede bridge definida pelo usuário, e criar os containers
nela:
• 1 rede bridge com nome lb-web
• Imagem para uso de containers "web": httpd (consulte mais em https://hub.docker.com/_/httpd)
• Imagem para uso de container "load balancer": haproxy:1.6 (consulte mais em https://hub.docker.com/_/haproxy)
• Diretório no container de configuração do balanceador: /usr/local/etc/haproxy/
• Arquivo de configuração do balanceador: haproxy.cfg (em anexo)
• Arquivos de FRONT para container web1: em anexo (fonte modificada em https://startbootstrap.com/themes/landing-page/)
• Arquivos de FRONT para container web2: em anexo (fonte modificada em https://startbootstrap.com/themes/landing-page/)
Qual comando usado para criar a rede bridge definida pelo usuário chamada "lb -web"?
Quais comandos usados para criar os volumes vol -web1 e vol-web2; e os containers, em background, web1 e web2, ingressantes na rede criada,
respectivamente?
Quais comandos usados para enviar os arquivos, contidos em anexo, do FRONT dos websites dos containers web1 e web2, respectiv amente?
Qual comando usado para criar e iniciar o container balanceador, de nome "lb", disponibilizado na porta 80, ingressante da re de criada e com mapeamento de
configuração no diretório /usr/local/etc/haproxy/ do container?
Envie o print da tela de acesso web de cada resposta, do container web1 e container web2:
Fazer download dos arquivos de recursos
ARQUIVOS_
TAREFA_5...
ARQUIVOS_
TAREFA_5...
ARQUIVOS_
TAREFA_5
RESPOSTA
Qual comando usado para criar a rede bridge definida pelo usuário chamada "lb -web"?
Lembre-se do "docker network create"
Quais comandos usados para criar os volumes vol -web1 e vol-web2; e os containers, em background, web1 e web2, ingressantes na rede criada,
respectivamente?
Lembre-se do "docker volume create" e mapeamento de volumes, no docker run, usando a option -'v', em cada diretório web /usr/local/apache2/htdocs dos
containers web1 e web2, respectivamente
Quais comandos usados para enviar os arquivos, contidos em anexo, do FRONT dos websites dos containers web1 e web2, respectiv amente?
Lembre-se do "docker cp".
Ex1: copiar um arquivo - docker cp ./src/build/index.html ContainerName:/app/
Ex2: copiar todos os arquivos do diretório - docker cp ./src/build/. ContainerName:/app/
Qual comando usado para criar e iniciar o container balanceador, de nome "lb", disponibilizado na porta 80, ingressante da re de criada e com mapeamento de
configuração no diretório /usr/local/etc/haproxy/ do container?
IMPORTANTE: é preciso que tenha criado os containers web primeiro. Caso contrário, terá um resultado inesperado!
A estrutura do docker run para criar esse container deve seguir esses pontos:
1. liberação da porta 80 usando '-p'
2. mapeamento de diretório, onde contém o arquivo haproxy.cfg (contido em anexo), com o diretório do container /usr/local/etc/haproxy/
3. ingresso na rede lb-web
4. imagem haproxy:1.6
Envie o print da tela de acesso web de cada resposta, do container web1 e container web2:
Enviar print das telas

Comandos Docker para administrar containers e imagens

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Comandos Docker para administrar containers e imagens

Enviado por

Direitos autorais:

Formatos disponíveis

1.

1-Comandos Docker inicial

Comando listar as imagens

Obs: Por padrão é baixado a versão latest

#apt-get update && apt-get install nmap

Plataforma: 64 bits e kernel superior a 3.10

* Somente na versão Trusty 14.04 (LTS) - Executar os seguintes comandos:

sudo apt-get update

sudo apt-get install linux-image-extra-$(uname -r) linux-image-extra-virtual

1 - Suporte a HTTPS no uso do apt

sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

2 - Adicionar chave GPG Docker Oficial

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

sudo apt-key fingerprint 0EBFCD88

4 - Adicionar repositório Docker 'stable'

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu

5 - Atualizar lista de repositórios:

sudo apt-get update

sudo apt-get install docker-ce

Se exibir informações sobre a plataforma Docker, tudo foi instalado corretamente!!

Criando acesso web -Portainer.io

01 - Baixar a imagem base do Debian oficial

sudo docker pull debian

02 - Verificar todas as imagens contidas no repositório local (atente-

sudo docker images

03 - Criar um container a partir da imagem base Debian:

sudo docker run debian

04 - Listar os containers ativos (iniciados) na Engine Docker:

05 - Listar TODOS os containers (ativos e inativos) na Engine Docker:

06 - Criar um container a partir da imagem base Debian, executando o

sudo docker run debian cat /etc/issue.net

07 - Listar TODOS os containers (ativos e inativos) na Engine Docker:

08 - Criar um container a partir da imagem base Debian, usando os

sudo docker run -itd --name SEUNOME debian

OBS: os parâmetros -itd permitem que o container seja executado e

09 - Listar os containers ativos (iniciados) na Engine Docker (observe

10 - Crie um container, de imagem do Ubuntu, onde será preciso

sudo docker run -it ubuntu bash

# sudo apt-get update && sudo apt-get install nano

Orientações sobre este módulo

Seja bem-vindo(a) ao Módulo "Administração Básica de containers e imagens"

Neste módulo serão abordados os seguintes conteúdos:

Docker Lifecycle - o ciclo de vida de imagens e containers

Executar, parar e remover

É necessário obter mais informações

Se interagir é preciso, fazer backup também

Pesquisar imagens também é fundamental

Posso administrar direto no navegador web?

Ao final desta seção, será preciso fazer as seguintes atividades:

Questionário - Administração Básica de containers e imagens

Mão na massa "Tendo controle de tudo"

Tarefa - "E se eu precisar recuperar um container?"

E, por fim, você:

Entenderá como funciona a dinâmica dos ciclos de vidas de containers e imagens

Conhecerá comandos Docker que permitem controlar os diversos estados de um container

Conhecerá maneiras para solicitar interação com containers

Aplicará recurso de backup, em arquivo tar, e recuperação de containers e imagens

Administrará containers e imagens diretamente no navegador web

Desejo sucesso no curso!

TRABALHANDO COM CONTAINERS

Listando todas imagens

Monitorando containers ativos

Interagindo no terminal do containers inativo