1. O modo de rede dos dockers
obtém o número do processo do contêiner
docker inspect -f '{
{.State.Pid}}' ID do contêiner/nome do contêiner
As características do modo de rede do docker
No estado inicial do docker, existem três modos de rede padrão, bridg (ponte), host (host), nenhum (sem configurações de rede)
[root@localhost ~]#docker network ls
Descrição da configuração do modo de rede
host//modo do host –network host O container e o host compartilham o namespace da rede
container//modo do container –network container: o id ou nome do container O container compartilha o namespace da rede com o container especificado
nenhum// Sem modo de rede – O contêiner de nenhum rede tem seu próprio namespace de rede, mas não há
modo de configuração de ponte//ponte – o contêiner de ponte de rede tem seu próprio namespace de rede e tem IP independente, porta, roteamento, etc., usando o par veth para conectar-se à ponte docker0 e usar a ponte docker0 como
modo de host do host do gateway 1.1
Equivalente ao modo bridge no VMware, está na mesma rede da máquina host, mas não possui endereço IP independente. O Docker usa a tecnologia Linux Namespaces para isolar recursos, como processo de isolamento de Namespace PID, sistema de arquivos de isolamento Mount Namespace, rede de isolamento de Namespace de rede, etc. Um Network Namespace fornece um ambiente de rede independente, incluindo placas de rede, roteamento, regras iptable, etc. são isolados de outros Network Namespacel. Um contêiner do Docker geralmente é atribuído a um Network.Namespace independente.
No entanto, se o modo de host for usado ao iniciar o contêiner, o contêiner não obterá um namespace de rede independente, mas compartilhará um namespace de rede com o host. O contêiner não virtualizará sua própria placa de rede, configurará seu próprio IP etc., mas usará o IP e a porta do host.
O contêiner e o host compartilham o namespace da rede, mas não há endereço IP independente. O endereço IP do host é usado e o intervalo de portas é compartilhado com o host. Por exemplo, se o host usar a porta 80, o contêiner não poderá use a porta 80. Este modo é mais conveniente, mas não seguro.
#Create container web1, especifique o modo de rede como host
#O container e o host compartilham o namespace da rede, mas não possuem endereço IP independente. Use o IP do host e compartilhe o intervalo de portas com o host.
docker run -d --name web1 --net=host nginx
#Acesse
o ip e a porta 80 da máquina host, então você pode acessar o serviço nginx de tt1
curl http://192.168.50.24:80
1.2 modo container
Depois de entender o modo host, este modo é fácil de entender. Este modo especifica que um contêiner recém-criado compartilha um Namespace de rede com um contêiner existente em vez de compartilhá-lo com o host. O contêiner recém-criado não criará sua própria placa de rede, nem configurará seu próprio Ie, mas compartilhará re, faixa de porta, etc. com um contêiner especificado. Da mesma forma, além dos aspectos de rede dos dois contêineres, outras coisas, como sistemas de arquivos e listas de processos, ainda estão isoladas. Os processos dos dois contêineres podem se comunicar por meio do dispositivo de placa de rede lo.
O contêiner B recém-criado e o contêiner A compartilham um namespace. Se o contêiner A usa a porta 80, o contêiner B não pode usar a porta 80.
#Crie um container chamado web2 baseado na imagem centos:7
docker run -itd --name web2 centos:7 /bin/bash
#Veja o número pid do container web2
docker inspect -f '{
{.State.Pid}} ' web2
#Exiba o namespace de rede de web2
ls -l /proc/web2's pid/ns
#Crie um contêiner web3, use o modo de rede de contêiner e compartilhe o namespace de rede com web2
docker run -itd --name web3 --net=container: web2 centos :7 bash
#Veja o pid do container web3
docker inspect -f '{
{.State.Pid}}' web3
ls -l /proc/web3's pid/ns/
#Você pode ver que web3 e web2 compartilham o mesmo espaço de nomes de rede
1.3 modo nenhum
No modo nenhum, o contêiner do Docker tem seu próprio namespace de rede, mas não executa nenhuma configuração de rede para o contêiner do Docker. Ou seja, o container locker não possui placa de rede, IP, roteamento e outras informações. Neste modo de rede, o contêiner possui apenas a rede lo loopback e não há outras placas de rede. Este tipo de rede não pode ser conectado à Internet. Uma rede fechada pode garantir a segurança do contêiner.
1.4 modo de ponte de ponte
O modo bridge é o modo de rede padrão do docker, sem o parâmetro --net, é o modo bridge.
Equivalente ao modo nat no VMware, o contêiner usa um namespace .network independente e se conecta à placa de rede virtual docker. Através da ponte dockerO e iptables
A configuração da tabela nat se comunica com o host. Este modo alocará hetwork Mamespace, configurações, etc. para cada contêiner e conectará um contêiner Docker em um host a uma ponte de rede virtual.
(1) Quando o processo do Docker for iniciado, uma ponte de rede virtual chamada docker0 será criada no host e o contêiner do Docker iniciado nesse host será conectado a essa ponte virtual. O modo de funcionamento da ponte virtual é semelhante ao de um switch físico, de modo que todos os contêineres no host sejam conectados a uma rede de camada 2 por meio do switch.
(2) Atribua um IP ao contêiner da sub-rede docker0 e defina o endereço I de dockerO como o gateway padrão do contêiner. Crie um par de dispositivos NIC virtuais no host. Os dispositivos Veth sempre aparecem em pares e formam um canal de dados. Quando os dados entram de um dispositivo, eles saem do outro dispositivo. Portanto, os dispositivos veth costumam ser usados para conectar dois dispositivos de rede.
(3) O Docker coloca uma extremidade do dispositivo veth pair no contêiner recém-criado e o nomeia eth0 (a placa de rede do contêiner) e coloca a outra extremidade no host, nomeando-o com um nome semelhante como veth*, e adiciona este dispositivo de rede à ponte docker0. Ele pode ser visualizado através do comando brctl show.
(4) Ao usar docker run -p, o docker realmente cria regras DNAT no iptables para realizar a função de encaminhamento de porta. Você pode usar iptables -t nat -vnL para visualizar.
[root@localhost opt]#docker run -id --name c1 centos:7
[root@localhost opt]#docker run -id --name c2 centos:7
[root@localhost opt]#docker run -id --name c3 centos:7
[root@localhost opt]#brctl show
[root@localhost opt]#docker run -id --name c4 -p 8080:80 centos:7
[root@localhost opt]#brctl show
[root@localhost opt ] ]#docker ps -a
1.5 Rede personalizada do contêiner
ifconfig docker0
Crie uma rede personalizada:
docker network create --subnet=172.66.0.0/16 --opt "com.docker.network.bridge.name"="docker1" mynetwork
docker network create --subnet=172.66.0.0/16 -- opte por "com.docker.network.bridge.name"="docker1" minha rede
Crie o container com o IP especificado novamente:
docker run -id --net=mynetwork --ip 172.66.0.66 --name a3 centos:7
ping 172.66.0.66
Experiência de produção de rede de contêiner Docker, recomendações de rede docker e "contraste" de IP de host:
Por exemplo, o endereço da máquina host é 10.2.5.6 e o endereço do contêiner pode ser alterado para 172.5.6.x, o que facilita a localização do nó com falha quando ocorre uma falha.
Excluir uma rede personalizada:
Se você deseja excluir uma rede personalizada, pode usar o nome do modo de rede docker network rm para excluir, como docker network rm mynetwork.
Antes de excluir um modo de rede, você precisa se certificar de que o contêiner criado usando esse modo de rede foi encerrado (ou seja, parado). A rede não pode ser excluída se o contêiner ainda estiver em execução.
2. Controle de recursos do contêiner Docker
O Docker usa o Cgroup para controlar a cota de recursos usada pelo contêiner, incluindo CPU, memória e disco, que basicamente abrange a cota de recursos comuns e o controle de uso. Cgroup é a abreviação de ControlGroups. É um mecanismo fornecido pelo kernel Linux que pode limitar, gravar e isolar os recursos físicos (como cpu, memória, disco, io, etc.) usados por grupos de processos. É usado por grupos de processos muitos projetos, como LXC e docker Implementar controle de recursos de processo. O próprio Cgroup é uma infraestrutura que fornece funções e interfaces para gerenciar processos em grupos, e o gerenciamento de recursos específicos, como E/S ou controle de alocação de memória, é realizado por meio dessa função.
Limite de recursos: você pode limitar a quantidade total de recursos usados pela tarefa.
Alocação de prioridade: por meio do número de fatias de tempo de CPU alocadas e do tamanho da largura de banda de E/S do disco, é realmente equivalente a controlar a prioridade de execução da tarefa.
Estatísticas de recursos: você pode contar o uso de recursos do sistema, como duração da CPU, uso de memória, etc.
Controle de tarefas: o cgroup pode executar operações como suspender e retomar tarefas.
3. Limites da CPU do host ocupada pelo docker
3.1 Limite superior de uso da CPU
O Linux usa CFS (Completely Fair Scheduler) para agendar o uso da CPU por cada processo. O período de agendamento padrão do CFS é de 100 ms. Podemos definir o ciclo de agendamento de cada processo de contêiner e quanto tempo de CPU cada contêiner pode usar no máximo durante esse ciclo.
Use --cpu-period para definir o período de agendamento e use --cpu-quota para definir o tempo de CPU que o contêiner pode usar em cada período. Os dois podem ser usados juntos. O intervalo efetivo do período CFS é de 1ms~1s, e o intervalo de valores do --cpu-period correspondente é de 1000~1000000 (em microssegundos). A cota de CPU do container não deve ser menor que 1ms, ou seja, o valor de --cpu-quota deve ser >= 1000. A cota de CPU do container não deve ser menor que 1ms, ou seja, o valor de --cpu-quota deve ser >= 1000.
1 segundo = 1000 milissegundos = 1000000 microssegundos
cd /sys/fs/cgroup/cpu/docker/3ed82355f81151c4568aaa6e7bc60ba6984201c119125360924bf7dfd6eaa42b/
cat cpu.cfs_quota_us
-1
cat cpu.cfs_period_us
100000
--------------------------------------------- -------------------------------------------------- ----------
#cpu.cfs_period_us: O período de alocação da CPU (microssegundos, portanto o nome do arquivo é representado por nós), o padrão é 100000.
#cpu.cfs_quota_us: Indica o tempo (em microssegundos) que o limite de cgroups leva, e o padrão é -1, o que significa sem limite. Se for definido como 50000, significa que 50000/100000=50% da CPU está ocupada.
(1) CPU normalmente habilitada, teste o limite superior de
uso
:7
[root@localhost ~ ]#docker ps -a
[root@localhost ~]#docker exec -it c1 bash
[root@d6da0a6b999a /]# vi cpu.sh
#!/bin/bash
i=0
while true
do
let i++
concluído
[root@d6da0a6b999a /]# chmod +x cpu.sh
iniciar script de loop infinito
[root@d6da0a6b999a /]# ./cpu.sh
A partir desse resultado, pode-se ver que é muito perigoso se o limite de uso da CPU não for limitado ao criar um contêiner. Uma vez que a exceção do programa de um determinado contêiner caia em um loop infinito, isso levará diretamente à interrupção dos negócios em outros recipientes
(2) Modifique a regra de limite superior de fragmentação de tempo padrão do contêiner e crie um teste de inicialização novamente para
inserir diretamente a modificação do arquivo de configuração
docker start c1
docker ps -a
#d6da0a6b999aeaac89e2ce883b6ff057abd5f4c2319d9a539635ff8e1f43fe04为容器id
cd /sys/fs/cgroup/cpu/docker/d6da0a6b999aeaac89e2ce883b6ff057 abd5f4c2319d9a539635ff8e1f43fe04
[root@localhost d6da0a6b999aeaac89e2ce883b6ff057abd5f4c2319d9a539635ff8e1f43fe04]#echo 50000 > cpu.cfs_quota_us
(3) Especifique o limite superior do uso de recursos da CPU do contêiner ao criar o contêiner
docker run -id --name c2 --cpu-quota 30000 centos:7
[root@localhost docker]#docker exec -it c2 bash
[ root@10cfa036ff07 /] # vim cpu.sh
#!/bin/bash
i=0
while true
do
let i++
done
[root@10cfa036ff07 /]# vi cpu.sh
[root@10cfa036ff07 /]# chmod +x cpu.sh
[ root@10cfa036ff07 /] # ./cpu.sh
（4）多cpu分配容器的使用上限
[root@localhost docker]#docker run -id --name c3 centos:7
[root@localhost docker]#docker ps -a
[root@localhost docker]#cd /sys/ fs/cgroup/cpu/docker/a1ce6948cdb6167570e6ef2101bb407d7de79407fbd9b9ac737ed40487f91a5a/
[root@localhost a1ce6948cdb6167570e6ef2101bb407d7de79407fbd9b9ac737 ed40487f91a5a]#ls
[root@localhost a1ce6948cdb6167570e6ef2101bb407d7de79407fbd9b9ac737ed40487f91a5a]#echo 200000 > cpu.cfs_quota_us
[root@localhost ~]#docker exec -it c3 bash
[root@a1ce6948cdb6 /]# vi cpu.bash
#!/bin/bash
i=0
while true
do
let i++
done
[root@a1ce6948cdb6 /]# chmod +x . /cpu.bash
[root@a1ce6948cdb6 /]# ./cpu.bash
3.2 Definir a taxa de ocupação dos recursos da cpu
Nota: Este método só terá efeito quando vários contêineres forem
definidos. porcentagem de recursos de CPU ocupados pelo contêiner) para alocar
[root@localhost ~]#docker run -id --name b1 --cpu-shares 2048 centos:7
[root@localhost ~]#docker run -id --name b2 --cpu-shares 1024 centos:7
[root @localhost ~]#docker run -id --name b3 --cpu-shares 1024 centos:7
Abra três terminais e inicie o teste de pressão do recipiente:
#Três recipientes são as seguintes operações de medição de pressão
docker exec -it b1 bash
#Download da ferramenta de medição de pressão ambiente dependente
yum install -y epel-release
#Download da ferramenta de medição de pressão
yum install -y stress
#Executar quatro threads de medição de pressão
stress -c 4
#Abra outro terminal para visualizar as
estatísticas da janela de resultados do teste
A partir dos resultados do teste, pode-se ver que quando a CPU aloca fatias de tempo, o contêiner b1 tem o dobro de oportunidades que os contêineres b2 e b3 para obter fatias de tempo da CPU. No entanto, o resultado da alocação depende do status de execução do host e de outros contêineres naquele momento.Na verdade, não há garantia de que os contêineres b2 e b3 conseguirão obter fatias de tempo da CPU.
Por exemplo, os processos dos contêineres b2 e b3 estão sempre ociosos, então o contêiner b1 pode obter mais fatias de tempo de CPU do que os contêineres b2 e b3. Em casos extremos, por exemplo, apenas um contêiner está sendo executado no host, mesmo que seu compartilhamento de CPU seja de apenas 50, ele pode monopolizar os recursos de CPU de todo o host.
Os Cgroups só terão efeito quando os recursos alocados pelo container forem escassos, ou seja, quando os recursos utilizados pelo container precisarem ser limitados. Portanto, é impossível determinar quantos recursos de CPU são alocados para um contêiner simplesmente com base no compartilhamento de CPU de um contêiner. O resultado da alocação de recursos depende da alocação de CPU de outros contêineres em execução ao mesmo tempo e do status de execução do processos no recipiente.
3.3 Defina o contêiner para vincular a CPU especificada
para visualizar o número da CPU no host
superior
, pressione o número "1"
Vincule o núcleo para criar um contêiner
[root@localhost ~]#docker run -id --name b4 --cpuset-cpus 2 centos:7
exec no contêiner para teste de estresse:
yum install -y epel-release
yum insatll -y stress
stress -c 1
4. Limites de uso de memória
4.1 Limitar a memória máxima que um contêiner pode usar
A opção m (ou --memory=) é usada para limitar a memória máxima que um contêiner pode usar
docker run -itd --name d1 -m 512m centos:7 /bin/bash
docker stats
4.2 Limitar o tamanho de swap disponível para o contêiner
#Limitar o tamanho de swap disponível, --memory-swap
●Para enfatizar, --memory-swap deve ser usado junto com --memory (ou -m).
●Em circunstâncias normais, o valor de --memory-swap inclui a memória disponível do contêiner e a troca disponível.
●So -m 300m --memory-swap=1g significa: o contêiner pode usar 300M de memória física e pode usar swap de 700M (1G - 300M). Se definido como 0 ou não definido, o tamanho de troca que o contêiner pode usar é o dobro do valor de -m. Se o valor de --memory-swap for igual ao valor de -m, o contêiner não poderá usar swap. Se o valor --memory-swap for -1, isso significa que a memória usada pelo programa contêiner é limitada e o espaço de troca disponível não é limitado (o host pode usar quantos contêineres de troca houver).
O valor de #--memory-swap inclui a memória disponível do contêiner e a troca disponível, menos o valor de -m é o valor da troca disponível.
#Indica que o container pode usar 512M de memória física e pode usar 512M de swap. Como 1g menos 512m de
memória física, o valor restante é o swap disponível.
docker run -itd --name d2 -m 512m --memory-swap=1g centos:7 bash #
--memoryswap valor é o mesmo que -m valor, o que significa que o contêiner não pode usar swap docker run -itd -- name d3 - m 512m --memory-swap=512m centos:7 bash # Se o valor de --memory-swap for definido como 0 ou não definido, o tamanho de troca que o contêiner pode usar é o dobro do valor de - m. docker run -itd --name d4 -m 512m centos:7 bash # --memory-swap O valor é -1, o que significa que a memória usada pelo programa contêiner é limitada, mas o espaço de troca utilizável não é limitado (host O host pode usar quantos contêineres de swap tiver). docker run -itd --name d5 -m 512m --memory-swap=-1 centos:7 bash
5. Limitação do controle de configuração IO do disco (blkio)
-device-read-bps: limite a velocidade de leitura bps (volume de dados) em um determinado dispositivo, e a unidade pode ser kb, mb (M) ou gb.
--device-write-bps: limita a velocidade de gravação em bps (volume de dados) em um determinado dispositivo, a unidade pode ser kb, mb (M) ou gb.
A velocidade refere-se a operações de leitura e gravação por segundo 1M, 1G ou 1kb
--device-read-iops : Limita os iops (número de vezes) para ler um dispositivo
--device-write-iops : limita os iops (número de vezes) gravados em um determinado dispositivo
5.1 A velocidade de gravação do contêiner por padrão
[root@localhost ~]#docker run -id --name e1 centos:7
[root@localhost ~]#docker exec -it e1 bash
[root@8657384cb483 /]# dd if= / dev/zero of=/opt/test.txt bs=10M count=5 oflag=direct
## oflag=direct evita o cache causado pelo sistema de leitura e gravação de arquivos e evita afetar os resultados do teste
5.2 Crie um contêiner com limite de velocidade de gravação
[root@localhost ~]#docker run -it --name e3 --device-write-bps /dev/sda:1M centos:7 /bin/bash [root@
6c1b8bcf6b44 /]# dd if=/dev/zero of=/opt/test.out bs=10M count=5 oflag=direct
6. Limpe o espaço em disco ocupado pelo
docker docker system prune -a pode ser usado para limpar o disco, excluir contêineres fechados, volumes de dados inúteis e redes.
docker system prune -a