Docker
  • Introdução a Containeres e Docker
    • Introdução
    • O que é um container e suas vantanges
    • VM versus Container
    • Como funcionam os containers
    • Linux
    • Container sem Docker
      • cgroup
      • cpu.max
    • LxC
    • LxD
    • Containers versus Imagens
    • Arquitetura do Docker
    • Arquitetura do Docker mais a fundo
    • Projetos Open Source
  • Instalação do Docker
    • Linux
    • Windows
      • Docker Desktop
      • Rancher Desktop
      • WSL
    • Mac
    • Visual Studio Code
  • Primeiros Passos com Docker
    • Criação e listagem básica de um container
    • Interagindo com o container
    • Executando containers continuamente
      • nginx
      • docker container run
      • docker container run nginx
      • docker container run -d nginx
      • docker container exec
    • Como usar publish de porta
      • docker container stop
      • docker container start
      • docker container rm
      • docker container rm -f $(docker container ls -qa)
    • Containers e variáveis de ambiente
      • docker container run -e
  • Desafio
    • Desafio 01 - Banco de Dados Postgresql
    • Desafio 02 - Banco de Dados MySQL
    • Desafio 03 - Banco de Dados MongoDB
  • Executando a sua primeira aplicação em containers
    • Introdução
    • Preparando o container para a aplicação
    • Executando a aplicação
      • docker container cp
  • Primeiros Passos com Docker Images
    • Introdução
    • OverlayFS na Prática
    • Copy-on-Write
    • Formas de criar uma imagem Docker
    • Como funciona o Docker Commit
    • Docker Commit na Prática
      • docker commit
    • Entendendo melhor a sua imagem
      • docker image history
      • docker image inspect
    • Entrando mais a fundo na imagem
    • Como usar a imagem Docker no modo raiz
  • Avançando em imagens Docker com Dockerfile
    • O que é Dockerfile
    • Primeira Imagem com Dockerfile
      • docker image build
    • Como funciona a construção com Dockerfile
    • Possibilidades com Dockerfile
    • FROM
    • RUN
    • WORKDIR
    • COPY
    • ADD
    • LABEL
    • ENV
    • VOLUME
    • ARG
    • EXPOSE
    • USER
    • ENTRYPOINT
    • CMD
    • ENTRYPOINT versus CMD
    • Principais comandos com imagem
    • Imagem da aplicação com Dockerfile
    • Comparando Docker Commit com Dockerfile
  • Docker Registry
    • Introdução
    • Docker Hub
    • Sua imagem com o nome certo
    • Renomear imagens com Docker Tag
      • docker image tag
    • Enviando a sua primeira imagem para o Docker Hub
      • docker image push
      • docker image pull
  • Algumas boas práticas para construção de imagem
    • Um processo por container
    • Usar imagens confiáveis
    • Otimizar sempre a sua imagem
    • Uso inteligente das camadas
    • Dockerignore
  • Multistage Build
    • Introdução
    • Multistage build na prática
    • Target para fazer o build
      • docker image build --target
    • Imagem externa no Multistage build
    • Usar um estágio de build como base
  • Docker Volume
    • Introdução
      • docker volume
    • Bind Mount
    • Particularidades do Bind Mount
    • Bind Mount no Windows
    • Exemplo com Bind Mount
    • Docker Volume
      • docker volume create
      • docker volume inspect
      • docker volume ls
      • docker volume prune
      • docker volume rm
    • Onde ficam os arquivos do Docker volume?
    • Usando o volume no Dockerfile
    • Como fazer backup de um Docker Volume
    • Exemplo com Docker Volume
    • Storage tmpfs
    • Como criar algo funcional com o que aprendemos
  • Network
    • Introdução
    • Componentes do Docker Network
    • Rede Bridge na prática
      • docker network
      • docker network create
      • docker network inspect
      • docker network ls
      • docker network prune
      • docker network rm
    • Criando a sua rede bridge
      • docker network connect
      • docker network disconnect
    • Como funciona a rede bridge por dentro
    • Rede Host na prática
    • Rede none da prática
    • Como adicionar domínios no seu container
  • Aplicação 100% no Docker
    • Introdução
    • Criação da Imagem e Envio para o Docker Hub
    • Criação do Docker Network
    • Container do PostgreSQL
    • Container da Aplicação Web
    • Atualização da aplicação
  • Docker Compose
    • Introdução
      • docker compose
    • A evolução do docker compose
    • Criação básica de um Docker Compose
      • docker compose attach
      • docker compose build
      • docker compose config
      • docker compose cp
      • docker compose create
      • docker compose down
      • docker compose events
      • docker compose exec
      • docker compose images
      • docker compose kill
      • docker compose logs
      • docker compose ls
      • docker compose pause
      • docker compose port
      • docker compose ps
      • docker compose pull
      • docker compose push
      • docker compose restart
      • docker compose rm
      • docker compose run
      • docker compose scale
      • docker compose start
      • docker compose stats
      • docker compose stop
      • docker compose top
      • docker compose unpause
      • docker compose up
      • docker compose version
      • docker compose wait
      • docker compose watch
    • Variáveis de Ambiente
    • Volume Bind Mount
    • Docker Volume
    • Docker Network - Bridge
    • Docker Network - Host Driver e Add Host
    • Ordenando a execução dos containers
    • Compose com build de imagem
    • Como Parametrizar o Compose com Variáveis de Ambiente
    • Múltiplos Composes
    • Extends
    • Merge
    • Include
    • Profiles
    • Comandos importantes do Docker Compose
  • Troubleshooting
    • Introdução
    • Docker Info
    • Docker Events
    • Docker Logs
    • Docker Inspect
    • Docker Top
    • Docker Stats
    • Docker Exec
  • Resiliência e Gerenciamento de Recursos
    • Introdução
    • Docker Restart
      • Introdução
      • on-failure
      • unless-stopped
      • always
      • Docker Compose
    • Healthcheck
      • Introdução
      • Linha de Comando
      • Docker Compose
      • Direto na Imagem
    • Gerenciamento de Recurso
      • CPU
        • Como Gerenciar CPU
        • Prática
      • Memória
        • Como Gerenciar Memória
        • Prática
      • Docker Compose
  • Fazendo um ambiente mais seguro
    • Introdução
    • Docker Scout
      • Introdução
      • Verificação Simples de Imagem
      • Como adicionar um repositório
      • Primeira melhoria na imagem
  • BUSCA RÁPIDA
    • Referências
    • Comandos
      • docker commit
      • docker compose
      • docker container
      • docker image
      • docker network
      • docker volume
    • Dockerfile
Powered by GitBook
On this page
  • Monitoramento de CPU no Docker
  • 1. --cpu-period
  • 2. --cpu-quota
  • 3. --cpuset-cpus
  • 4. --cpus
  • Considerações Gerais e Usos Comuns
  • Exemplo Completo de Comando
  1. Resiliência e Gerenciamento de Recursos
  2. Gerenciamento de Recurso
  3. CPU

Como Gerenciar CPU

PreviousCPUNextPrática

Last updated 8 months ago

Monitoramento de CPU no Docker

O Docker permite limitar e gerenciar o uso de CPU dos containers de maneira granular, proporcionando um controle eficiente sobre os recursos disponíveis no sistema. Isso é especialmente útil em ambientes de produção, onde você pode querer garantir que determinados containers não consumam recursos excessivos. A seguir, são descritas as principais opções relacionadas ao gerenciamento de CPU no Docker, com explicações detalhadas, exemplos de entrada e saída, e cenários comuns de uso.

1. --cpu-period

O parâmetro --cpu-period especifica o período de tempo em microssegundos para a distribuição do uso de CPU dos containers. Ele funciona em conjunto com --cpu-quota para determinar a fração de CPU que o container pode usar.

Exemplo:

docker run --cpu-period=100000 --cpu-quota=25000 <imagem>

Nesse exemplo, o --cpu-period=100000 define um período de 100 mil microssegundos (100ms). Já o --cpu-quota=25000 limita o container a usar 25% de uma CPU durante esse período.

  • Entrada:

    • --cpu-period=100000

    • --cpu-quota=25000

  • Saída:

    • O container poderá usar 25% de uma CPU, com o período de verificação de uso reiniciado a cada 100ms.

Uso comum: Esse conjunto de parâmetros é útil quando você deseja garantir que um container use apenas uma fração limitada da CPU total, o que pode ser importante em ambientes de multi-tenancy, onde várias aplicações dividem o mesmo hardware.

2. --cpu-quota

O parâmetro --cpu-quota define o tempo máximo, em microssegundos, que o container pode usar dentro de um período definido por --cpu-period. Se você quer limitar o uso de CPU a uma quantidade específica, --cpu-quota é a maneira de fazer isso.

Exemplo:

docker run --cpu-quota=50000 <imagem>

Nesse caso, o container pode usar até 50% de uma CPU durante o período padrão de 100ms.

  • Entrada:

    • --cpu-quota=50000

  • Saída:

    • O container terá 50% de uma CPU disponível durante o período padrão de 100ms.

Uso comum: --cpu-quota é usado em situações onde é necessário garantir que um container não exceda um uso específico de CPU, mesmo que outras CPUs estejam disponíveis.

3. --cpuset-cpus

Este parâmetro permite que você especifique quais CPUs físicas (ou núcleos de CPU) o container poderá usar. O valor de --cpuset-cpus deve ser uma lista de números de núcleos separados por vírgulas.

Exemplo:

docker run --cpuset-cpus="0,1" <imagem>

Nesse caso, o container estará restrito a usar apenas os núcleos de CPU 0 e 1.

  • Entrada:

    • --cpuset-cpus="0,1"

  • Saída:

    • O container só poderá usar os núcleos de CPU 0 e 1, independentemente da carga ou disponibilidade de outros núcleos.

Uso comum: Este parâmetro é frequentemente utilizado para isolar containers em determinados núcleos, garantindo que eles não interfiram com outros containers ou processos críticos que estejam rodando em outros núcleos.

4. --cpus

O parâmetro --cpus é a maneira mais simples de limitar o uso de CPU de um container. Ele define quantas CPUs o container pode usar, com frações de CPU permitidas.

Exemplo:

docker run --cpus="1.5" <imagem>

Nesse exemplo, o container pode utilizar até 1.5 CPUs, ou seja, ele tem acesso total a uma CPU e pode utilizar metade de outra.

  • Entrada:

    • --cpus="1.5"

  • Saída:

    • O container terá acesso total a uma CPU e a 50% de uma segunda CPU.

Uso comum: --cpus é utilizado para limitar o uso de CPU de uma maneira mais intuitiva, sem a necessidade de definir períodos e cotas manualmente.


Considerações Gerais e Usos Comuns

Essas opções de controle de CPU são particularmente úteis em ambientes de alta densidade, onde muitos containers estão rodando simultaneamente e você deseja evitar que um container monopolize os recursos de CPU do sistema. Elas também são aplicadas em cenários de priorização de workloads, onde você quer garantir que processos críticos sempre tenham acesso preferencial aos recursos.

  • Ambientes de produção multi-tenant: onde diversos containers de diferentes clientes compartilham o mesmo host físico.

  • Garantia de qualidade de serviço (QoS): onde containers com prioridade mais baixa têm limites rigorosos de CPU para garantir que processos prioritários mantenham desempenho consistente.

  • Testes de stress: para simular ambientes com recursos limitados e avaliar o comportamento de uma aplicação quando restrita em termos de uso de CPU.

Exemplo Completo de Comando

docker run --cpus="2" --cpu-period=100000 --cpu-quota=50000 --cpuset-cpus="0,1" <imagem>

Neste exemplo, o container está restrito a usar até 50% de duas CPUs (uma CPU completa), com o uso restrito aos núcleos 0 e 1.


Esses parâmetros fornecem uma maneira poderosa de garantir controle de CPU sobre os containers, permitindo uma execução mais eficiente e previsível em ambientes complexos.