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
  1. Resiliência e Gerenciamento de Recursos
  2. Gerenciamento de Recurso

Docker Compose

Ambiente limpo:

$ docker container ls -a
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
$ docker image ls
REPOSITORY   TAG       IMAGE ID   CREATED   SIZE

Edição do arquivo compose.yaml:

$ vim compose.yaml
services:
  web:
    image: marcelodpbarbieri/simulador-caos:v2
    ports:
      - 8080:3000
    restart: always
    healthcheck:
      disable: true
    cpuset: "0"
    memswap_limit: 512M
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M
Explicação do comando

O trecho a seguir refere-se à definição de um serviço chamado web em um arquivo docker-compose.yaml. Vamos analisar cada parte em detalhes, explicando seu propósito e o impacto que as opções configuradas têm sobre a execução do container.

services:
  web:
    image: marcelodpbarbieri/simulador-caos:v2
    ports:
      - 8080:3000
    restart: always
    healthcheck:
      disable: true
    cpuset: "0"
    memswap_limit: 512M
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 512M

1. services

A chave services define os serviços que serão executados pelo docker-compose. Cada serviço é um container que será executado de acordo com a configuração definida no arquivo. No caso, o serviço web será baseado na imagem marcelodpbarbieri/simulador-caos:v2.

2. image: marcelodpbarbieri/simulador-caos:v2

A opção image especifica a imagem Docker que será usada para criar o container. No exemplo, a imagem marcelodpbarbieri/simulador-caos:v2 será baixada do Docker Hub (ou de um registro privado, se configurado) e usada para o serviço web. A tag v2 indica uma versão específica da imagem.

Exemplo de execução:

  • O container usará a versão v2 da imagem simulador-caos, publicada no repositório de marcelodpbarbieri.

3. ports: - 8080:3000

Aqui, a opção ports define o mapeamento de portas entre o host e o container. A sintaxe 8080:3000 significa que a porta 3000 do container será mapeada para a porta 8080 no host.

  • Entrada:

    • 8080:3000

  • Comportamento:

    • O serviço estará acessível na porta 8080 do host, mas dentro do container ele rodará na porta 3000.

Uso comum: Esse mapeamento permite que você exponha a aplicação dentro do container para o mundo externo via a porta 8080 do host.

4. restart: always

A política de reinício restart: always define que o container será reiniciado automaticamente se ele parar, independentemente da razão. Isso inclui falhas inesperadas e paradas manuais.

  • Comportamento:

    • O container será reiniciado sempre que for parado ou se houver falha, garantindo que ele permaneça ativo.

Uso comum: Esse comportamento é importante em ambientes de produção para garantir alta disponibilidade de serviços.

5. healthcheck: disable: true

A chave healthcheck normalmente é usada para verificar o estado de saúde do container, executando periodicamente comandos que determinam se o serviço está funcionando corretamente. No entanto, disable: true desativa essa verificação.

  • Comportamento:

    • O Docker não realizará nenhuma verificação de saúde do container, o que pode ser útil quando a aplicação tem seu próprio mecanismo de verificação ou não precisa de monitoramento constante.

Uso comum: Essa configuração é útil quando se quer evitar a sobrecarga de health checks, especialmente se o container já possui outras formas de monitoramento.

6. cpuset: "0"

O parâmetro cpuset (equivalente a cpuset-cpus na linha de comando Docker) define em quais CPUs o container pode ser executado. No exemplo, cpu-set: "0" limita a execução do container ao primeiro núcleo de CPU (núcleo 0).

  • Entrada:

    • cpuset: "0"

  • Comportamento:

    • O container só poderá utilizar o núcleo de CPU 0, o que isola sua carga de processamento para um núcleo específico.

Uso comum: Esse recurso é usado em ambientes onde se deseja controlar quais CPUs estão alocadas para determinados containers, evitando que eles interfiram com outros processos ou containers.

7. memswap_limit: 512M

Este parâmetro define o limite combinado de memória física (RAM) e swap que o container pode usar. O valor 512M significa que o container poderá usar até 512MB de RAM mais swap, se necessário.

  • Entrada:

    • memswap_limit: 512M

  • Comportamento:

    • O container terá um limite de 512MB de memória e swap combinados, o que ajuda a evitar que ele consuma muita memória do sistema.

Uso comum: Limitar o uso de memória é útil em sistemas com recursos limitados ou onde é necessário evitar que um único container cause esgotamento de memória no host.

8. deploy: resources: limits: cpus: "0.5" memory: 512M

A seção deploy é usada para definir configurações de deploy, particularmente no Docker Swarm, mas também pode ser aplicada localmente para limitar o uso de recursos de um container.

  • cpus: "0.5":

    • Define o limite de uso de CPU do container. Nesse exemplo, cpus: "0.5" limita o container a usar até 50% de uma CPU.

  • memory: 512M:

    • Define que o container pode usar no máximo 512MB de RAM.

Exemplo:

deploy:
  resources:
    limits:
      cpus: "0.5"
      memory: 512M
  • Entrada:

    • cpus: "0.5"

    • memory: 512M

  • Comportamento:

    • O container só poderá usar 50% de uma CPU e terá seu uso de memória limitado a 512MB.

Uso comum: Definir limites de recursos é fundamental em ambientes com múltiplos containers, garantindo que nenhum container utilize mais do que sua cota de CPU e memória, preservando a estabilidade do sistema como um todo.


Considerações Gerais

Este arquivo docker-compose.yaml configura um serviço com limites de CPU e memória cuidadosamente definidos, além de uma política de reinício para garantir alta disponibilidade. Os parâmetros de CPU e memória são usados para controlar o impacto que esse serviço terá no sistema host, garantindo que ele não consuma mais recursos do que o alocado.

Esse tipo de configuração é ideal em ambientes onde:

  • O uso de recursos precisa ser controlado rigidamente.

  • A aplicação precisa estar disponível continuamente, sem interrupções.

  • O monitoramento de saúde é desativado por motivos de otimização ou simplicidade, e outros mecanismos de monitoramento são usados.

Em resumo, essa configuração garante que o serviço web esteja isolado em termos de CPU e memória, com um comportamento previsível e controlado.

Subida do Docker Compose:

$ docker compose up -d
[+] Running 15/15
 ✔ web Pulled                                                              37.9s
   ✔ 90e5e7d8b87a Pull complete                                            19.7s
   ✔ 27e1a8ca91d3 Pull complete                                            20.6s
   ✔ d3a767d1d12e Pull complete                                            23.8s
   ✔ 711be5dc5044 Pull complete                                            31.6s
   ✔ 22956530cc64 Pull complete                                            31.7s
   ✔ 8120d733fe37 Pull complete                                            34.4s
   ✔ 29e2cea0cf4c Pull complete                                            34.5s
   ✔ 2e099399c08b Pull complete                                            34.5s
   ✔ d2326862f18a Pull complete                                            34.5s
   ✔ 4a2fcba3cfd3 Pull complete                                            34.6s
   ✔ c4982a7d5cd5 Pull complete                                            35.7s
   ✔ 8f6c95ba1d1b Pull complete                                            35.9s
   ✔ b8ed20694ad9 Pull complete                                            35.9s
   ✔ 8152f71c04d1 Pull complete                                            35.9s
[+] Running 2/2
 ✔ Network marcelo_default  Created                                         0.2s
 ✔ Container marcelo-web-1  Started                                         0.9s

Container em execução:

$ docker container ls
CONTAINER ID   IMAGE                                 COMMAND                  CREATED         STATUS         PORTS                                       NAMES
393cd02545a7   marcelodpbarbieri/simulador-caos:v2   "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   0.0.0.0:8080->3000/tcp, :::8080->3000/tcp   marcelo-web-1

Monitoramento:

$ htop

Alto Consumo de CPU e Memória:

PreviousPráticaNextFazendo um ambiente mais seguro

Last updated 8 months ago