-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathDockerWindowsWsl
185 lines (141 loc) · 12.5 KB
/
DockerWindowsWsl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
AVISO⚠️:
□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%
Quando você executa um container no WSL (Windows Subsystem for Linux) para Ubuntu e realiza atualizações dentro desse container,
a memória do seu Windows é afetada porque o WSL compartilha recursos com o sistema operacional host, neste caso, o Windows.
O WSL é uma camada de compatibilidade que permite executar um ambiente Linux diretamente no Windows,
mas ainda é parte integrante do sistema operacional Windows. Quando você executa um container no WSL,
o Docker usa a infraestrutura do WSL para gerenciar e executar o container.
Quando você realiza atualizações dentro do container, os dados e as alterações feitas dentro desse ambiente são armazenados no sistema de arquivos do WSL,
que por sua vez está armazenado na unidade do Windows. Portanto, mesmo que o ambiente Linux esteja sendo executado em um container isolado,
os dados e as alterações feitas dentro desse ambiente ainda ocuparão espaço no sistema de arquivos do Windows.
Essa abordagem tem a vantagem de permitir a integração entre o Windows e o ambiente Linux,
mas também significa que o espaço utilizado pelo sistema de arquivos do WSL,
incluindo os dados do container, será refletido na utilização de espaço no disco do Windows.⚠️
□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%□□□□□0%
Baixe o docker para windows:
https://docs.docker.com/desktop/install/windows-install/
Após isso, siga passo a passo do software (instalação padrão).
Dica pessoal: Quando o docker for instalado, você pode abrir o terminal dele e operar. Mas prefiri baixar o ubuntu no wsl, para simular melhor o sistema linux.
https://ubuntu.com/wsl
Após isso, só executar o terminal do ubuntu, pesquise-o e siga essas outras etapas e comandos.
- docker run hello-world
Deve aparecer esta mensagem:
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
c1ec31eb5944: Pull complete
Digest: sha256:4bd78111b6914a99dbc560e6a20eab57ff6655aea4a80c50b0c5491968cbc2e6
Status: Downloaded newer image for hello-world:latest
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/get-started/
O hello world só funcionou pois a imagem existe. Se ela existir, ele acesso o docker hub e puxa as informações. olhe este link https://hub.docker.com/_/hello-world
Essa imagem já existe. Só apenas pusermos um nome aleatório, nós precisaremos criar a imagem ou ele irá apresentar erros devido a falta de imagens.
Hello World! (an example of minimal Dockerization)
Neste outro exemplo, o nosso container terá uma imagem relacionada ao sistema operacional ubuntu: https://hub.docker.com/_/ubuntu
-------------------------------------------------------------------------------------------------------------------------------------
Veja este cenário: queremos baixar a imagem do ubuntu para um container, vamos passo a passo:
1) Pesquise no docker hub o nome da imagem do ubuntu
2) Após descobrir o nome, vamos baixar ela com o comando: docker pull ubuntu
3) E agora a sua execução: docker run ubuntu
Dúvidas: Perceba que se você fizer esse passo a passo, no passo três não acontecerá nada (aparentemente). A explicação para isso é: Na verdade ele subiu o container
e executou o comando bash, cummprindo seu objetivo principal e partir disso não tinha mais operações (processos) dentro dele, por isso não aparecerá caso você execute
o comando docker ps ou docker container ls. Para o container permanecer ativo, precisa de no mínimo um processo atuando nele. Vamos por um bem simples, veja:
docker run ubuntu sleep 1d
e teremos isso como resultado (ele ainda estará operando):
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
b62a159d7c17 ubuntu "sleep 1d" 20 seconds ago Up 18 seconds dreamy_hodgkin
A segunda pergunta que precisamos responder é o que aconteceu nos bastidores para que nosso container pudesse ser executado daquela primeira vez?
Na ocasião em que nosso host, o Ubuntu neste caso, executou o comando docker run ubuntu, docker pull ubuntu,
ele simplesmente foi até o Docker Hub e solicitou a imagem chamada Ubuntu. O Docker Hub respondeu afirmando ter essa imagem e a disponibilizou para nós.
Realizamos o download dessa imagem, e em seguida, nosso host fez, na etapa em que observamos o digest e sha256,
uma validação para assegurar a autenticidade da imagem, verificando se é realmente a imagem que procurávamos.
Ao realizar o docker run, se não a tivermos localmente, buscamos no Docker Hub,
validamos através de um hash e executamos nosso container.
Este geralmente possui, como visto no caso do Ubuntu, um comando padrão a ser executado, que, ao compararmos com o menu rodando o comando docker ps -a no terminal,
seria o bash.
Caso não tenhamos cuidado, acabaremos criando containers zumbis que iniciarão e logo encerrarão, pois não teremos nenhum processo impedindo sua finalização.
Contudo, agora sabemos que, mantendo pelo menos um processo, nosso container permanecerá em execução.
Etapas do run:
Procura a imagem localmente -> Baixa a imagem caso não encontre localmente -> Valida o hash da imagem -> Executa o container.
--------------------------------------------------------------------------------------------------------------------------------------
COMANDOS DOCKER:
docker run imagem (Executar a imagem)
docker pull imagem (Apenas para baixar essa imagem)
docker ps ou docker container ls (Apresentar containers EM execução)
docker ps -a ou docker container ls -a (Apresentar containers que ESTAVAM em execução)
docker stop CONTAINER ID ou NAMES (Parar a execução daquele container); pode usar o -t=0 para tirar o tempo de 10 segundos (docker stop ID -t=0)
docker start CONTAINER ID ou NAMES (Voltar a execução daquele container)
docker pause CONTAINER ID (Pausa o container)
docker unpause CONTAINER ID (Volta o container para operação)
docker exec -it CONTAINER ID bash (Permite executar um comando em um container que já está em execução.)
docker run -it imagem (ubuntu,etc) bash (Iniciar container e entrar dentro de seu terminal)
docker rm CONTAINER ID (Remove container)
docker volume prune (Você pode verificar se existem volumes não utilizados que podem estar retendo espaço em disco. Listar e remover volumes não utilizados)
docker container prune (Se você quiser remover todos os containers que não estão em execução)
docker image prune ( Apagar imagens não utilizadas)
docker run -d -P
docker run -d -p (Informar porta)
docker rm id_container -- force
docker port id_container
Com a execução deste último comando citado, aparecerá no terminal:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f27e6e53ced3 hello-world "/hello" 15 minutes ago Exited (0) 15 minutes ago tender_herschel
72f962bc4498 hello-world "/hello" 23 hours ago Exited (0) 23 hours ago admiring_gauss
PARA VOCÊ INTERAGIR NO CONTAINER (ENTRAR NO CONTAINER) TEMOS UM COMANDO:
docker exec -it CONTAINER ID bash ( -i modo de interação -t acessar o TTY que é o terminal do container; bash para navegar dentro do ubuntu)
docker container exec [OPTIONS] CONTAINER COMMAND [ARG...]
https://docs.docker.com/engine/reference/commandline/container_exec/
É aqui que entra a questão dos namespaces. Tudo que você fizer dentro do docker permanecerá lá, vai estar isolado.
Quando você sair (exit) e der docker stop, o container de certa forma meio que mata os processos, (sigikill) que estavam antes lá
Problema vim nos containers: https://unix.stackexchange.com/questions/336392/e-unable-to-locate-package-vim-on-debian-jessie-simplified-docker-container
Mapeamento de portas entre o host e o container.:
https://hub.docker.com/r/dockersamples/static-site (vamos testar essa imagem)
Para executar essa imagem e sem travar o terminal e ser executado em segundo plano (em modo destacado) use a flag -d:
docker run -d dockersamples/static-site (para rodar sempre aberto, garante que o software do docker esteja aberto para o uso)
Teste o comando docker ps para verificar se o container subiu e está em execução. O comando que você verá está mantendo esse container em execução, diferente dos outros que estavam morrendo.
Para usar a porta do container, precisamos expor ela de certa forma. Primeiro vamos eliminar esse container:
docker rm id_container --force (-- force serve para parar e remover o container)
Agora vamos executar novamente (lembrando que já temos o conteúdo desse conteiner salvo em nossa máquina!!)
docker run -d -P dockersamples/static-site
Perceba que as portas vão estar bagunçadas e "complicadas de entender"
Vamos testar um comando:
docker port id_container (serve para mostrar o mapeamento de portas de um container em relação ao host)
ele informará que a porta 80 está sendo mapeada para outro valor em nosso host, exemplo:
docker port id_container
80/tcp -> 0.0.0.0:32771 (32771 valor que representara essa porta em nosso host;Porta 80 do container foi mapeada para a porta 32771 do nosso local host)
443/tcp -> 0.0.0.0:32770
Agora execute em seu host, sem https:
localhost: 32771
Ele tem que abrir uma pagina hello docker
Outra forma importante de se entender:
Repetindo o processo de apagar e forçar o container, vamos executar novamente:
docker run -d -p 8080:80 dockersamples/static-docker (O -p minúsculo significa que vamos fazer um mapeamento específico de uma porta do nosso host. Leia os valores assim: A porta 8080 do nosso host reflte na porta 80 do
conteiner; Mapeia a porta 8080 do host para a porta 80 do contêiner.
Isso significa que o serviço dentro do contêiner que está escutando na porta 80 será acessível externamente através da porta 8080 do host
*INFORMAÇÃO EXTRA*:
--------------------------------------------------------------------------------------------------------
Porta 80: Web (HTTP) Porta 443: Web segura (HTTPS) Porta 8080: Console Web solicitando informações (HTTP)
--------------------------------------------------------------------------------------------------------
Para testar, tente localhost:80 (Irá dar erro. Pois os namespaces isolam as interfaces de rede, ou seja: a porta 80 do container é diferente da porta 80 do dispositivo host; estão isoladas!
===============================================================================================================================================================
PID Namespace (pid): Isola o espaço de processos, permitindo que cada contêiner tenha sua própria árvore de processos.
Network Namespace (net): Isola o stack de rede, incluindo interfaces de rede, tabelas de roteamento e firewalls. Cada contêiner tem sua própria pilha de rede.
Mount Namespace (mnt): Isola o sistema de arquivos, permitindo que cada contêiner tenha seu próprio sistema de arquivos raiz montado.
UTS Namespace (uts): Isola o hostname e o domínio NIS (Network Information Service).
IPC Namespace (ipc): Isola os recursos de IPC (Inter-Process Communication), como filas de mensagem e semáforos.
User Namespace (user): Permite mapear IDs de usuário dentro do contêiner para IDs diferentes fora do contêiner,
melhorando a segurança e permitindo que um contêiner execute processos como um usuário não privilegiado fora do contêiner.
===============================================================================================================================================================