• Verificar a versão do Docker instalada:

  1. docker --version

  2. Exibe a versão do Docker instalada no sistema.

• Listar os containers em execução:

  1. docker ps

  2. Mostra uma lista dos containers que estão atualmente em execução.

• Listar todos os containers (em execução e parados):

  1. docker ps -a

  2. Exibe todos os containers, incluindo os que já foram executados e pararam.

• Listar as imagens Docker disponíveis:

  1. docker images

  2. Exibe uma lista de todas as imagens disponíveis localmente no sistema.

• Iniciar um container baseado em uma imagem:

  1. docker run -d nginx

  2. Inicia um container da imagem nginx em segundo plano (`-d` para detached mode).

• Executar um container interativamente:

  1. docker run -it ubuntu /bin/bash

  2. Inicia um container Ubuntu interativo (`-it` para modo interativo) e abre um shell bash no container.

• Parar um container em execução:

  1. docker stop nome_do_container

  2. Para um container em execução, identificando-o pelo nome ou ID.

• Remover um container parado:

  1. docker rm nome_do_container

  2. Remove um container que não está mais em execução.

• Remover uma imagem Docker:

  1. docker rmi nome_da_imagem

  2. Remove uma imagem Docker do sistema local.

• Obter logs de um container em execução:

  1. docker logs nome_do_container

  2. Exibe os logs do container especificado, permitindo visualizar a saída do processo dentro do container.

• Inspecionar um container para obter detalhes:

  1. docker inspect nome_do_container

  2. Exibe informações detalhadas sobre um container, incluindo configurações de rede, volumes e variáveis de ambiente.

• Iniciar um container parado:

  1. docker start nome_do_container

  2. Inicia um container que foi previamente parado.

• Acessar um container em execução:

  1. docker exec -it nome_do_container /bin/bash

  2. Abre um shell bash interativo dentro de um container que já está em execução.

• Remover todos os containers parados de uma vez:

  1. docker container prune

  2. Remove todos os containers parados do sistema, liberando espaço.

• Obter ajuda sobre os comandos do Docker:

  1. docker --help

  2. Exibe o menu de ajuda com a lista de comandos disponíveis do Docker.

• Criar e utilizar volumes Docker para persistência de dados:

  1. docker volume create meu_volume

  2. Cria um volume persistente chamado meu_volume, que pode ser usado por containers.

• Montar um volume em um container:

  1. docker run -d -v meu_volume:/var/www/html nginx

  2. Inicia um container nginx e monta o volume meu_volume no diretório `/var/www/html` do container, permitindo que dados persistam mesmo após a remoção do container.

• Listar todos os volumes criados:

  1. docker volume ls

  2. Exibe uma lista de todos os volumes Docker disponíveis.

• Remover volumes não utilizados:

  1. docker volume prune

  2. Remove todos os volumes que não estão sendo usados por nenhum container, liberando espaço no sistema.

• Criar uma rede personalizada no Docker:

  1. docker network create minha_rede

  2. Cria uma rede bridge chamada minha_rede que pode ser usada para conectar containers.

• Conectar um container a uma rede específica:

  1. docker run -d --network minha_rede nginx

  2. Inicia um container nginx e conecta-o à rede minha_rede, permitindo que ele interaja com outros containers na mesma rede.

• Listar todas as redes Docker disponíveis:

  1. docker network ls

  2. Exibe uma lista de todas as redes Docker criadas.

• Inspecionar uma rede Docker para obter detalhes:

  1. docker network inspect minha_rede

  2. Exibe informações detalhadas sobre a rede minha_rede, incluindo containers conectados, configuração de IP e outras propriedades.

• Desconectar um container de uma rede:

  1. docker network disconnect minha_rede nome_do_container

  2. Remove o container nome_do_container da rede minha_rede, mantendo o container em execução.

• Limitar o uso de CPU e memória de um container:
  1. Limitar a CPU a 50%:

docker run -d --cpus="0.5" nginx

1. Limitar a memória a 256MB:

docker run -d --memory="256m" nginx

1. Esses comandos iniciam containers nginx limitando o uso de CPU e memória, ajudando a controlar os recursos consumidos.

• Executar um container com prioridade de CPU (shares):

  1. docker run -d --cpu-shares 512 nginx

  2. Executa um container nginx com prioridade de CPU ajustada, onde 512 indica que o container receberá mais CPU que um container com shares padrão (1024 é o padrão).

• Limitar o uso de I/O no disco de um container:

  1. docker run -d --device-read-bps /dev/sda:1mb --device-write-bps /dev/sda:1mb nginx

  2. Limita a taxa de leitura e gravação no dispositivo `/dev/sda` a 1MB/s, controlando o uso de I/O do container.

• Renomear um container existente:

  1. docker rename container_antigo container_novo

  2. Renomeia o container container_antigo para container_novo, mantendo o container em execução.

• Verificar o uso de recursos (CPU, memória, rede, I/O) de containers:

  1. docker stats

  2. Mostra em tempo real o uso de CPU, memória, rede e I/O de todos os containers em execução.

• Verificar o histórico de uma imagem Docker:

  1. docker history nome_da_imagem

  2. Exibe o histórico de camadas de uma imagem Docker, incluindo comandos utilizados para a construção da imagem.

• Efetuar login no Docker Hub para baixar imagens privadas:

  1. docker login

  2. Realiza o login no Docker Hub (ou em outro registro Docker) para permitir o download de imagens privadas.

• Fazer o pull de uma imagem privada de um repositório:

  1. docker pull nome_do_usuario/imagem_privada

  2. Baixa uma imagem privada de um repositório após efetuar o login no Docker Hub.

• Construir uma imagem Docker personalizada com um Dockerfile:
  1. Criar um Dockerfile básico:

```

    FROM ubuntu:20.04
    RUN apt-get update && apt-get install -y nginx
    COPY ./meu_arquivo.html /var/www/html/index.html
    CMD ["nginx", "-g", "daemon off;"]
    ```
  - **Construir a imagem:**
    <code>docker build -t minha_imagem_customizada .</code>
  - Cria uma imagem personalizada chamada **minha_imagem_customizada** com base em um **Dockerfile**, que instala o **nginx** e copia um arquivo HTML.

• Listar as camadas de uma imagem Docker:

  1. docker history minha_imagem_customizada

  2. Exibe todas as camadas de uma imagem, mostrando quais comandos foram utilizados para construí-la.

• Executar uma imagem com variáveis de ambiente personalizadas:

  1. docker run -d -e VAR1=valor1 -e VAR2=valor2 minha_imagem_customizada

  2. Inicia um container da imagem minha_imagem_customizada com as variáveis de ambiente VAR1 e VAR2 definidas.

• Criar e usar um arquivo `.env` para variáveis de ambiente:
  1. Exemplo de arquivo `.env`:

```

    MYSQL_USER=user
    MYSQL_PASSWORD=secret
    ```
  - **Executar o container utilizando o `.env`:**
    <code>docker run --env-file .env mysql</code>
  - Utiliza um arquivo **`.env`** para definir variáveis de ambiente no container **MySQL**.

• Criar uma rede Docker entre múltiplos containers (Docker Compose):
  1. Criar um arquivo `docker-compose.yml`:

```

    version: '3'
    services:
      web:
        image: nginx
        ports:
          - "80:80"
      db:
        image: mysql
        environment:
          MYSQL_ROOT_PASSWORD: exemplo
    ```
  - **Iniciar múltiplos containers com Docker Compose:**
    <code>docker-compose up -d</code>
  - Utiliza o **Docker Compose** para orquestrar e iniciar múltiplos containers (um **nginx** e um **MySQL**) com uma única configuração.

• Parar e remover containers criados com Docker Compose:

  1. docker-compose down

  2. Para e remove todos os containers, redes e volumes criados pelo comando `docker-compose up`.

• Construir imagens com Docker Compose (build):
  1. Adicionar a seção build no `docker-compose.yml`:

```

    version: '3'
    services:
      web:
        build: .
        ports:
          - "80:80"
    ```
  - **Construir e iniciar os containers:**
    <code>docker-compose up --build</code>
  - Utiliza o **Docker Compose** para construir uma imagem personalizada com base em um **Dockerfile** no diretório atual.

• Limitar o uso de CPU e memória em Docker Compose:
  1. Adicionar limites no `docker-compose.yml`:

```

    version: '3'
    services:
      web:
        image: nginx
        deploy:
          resources:
            limits:
              cpus: "0.5"
              memory: "512M"
    ```
  - Limita o uso de **CPU** e **memória** para o serviço **nginx** utilizando **Docker Compose**.

• Inspecionar a rede criada pelo Docker Compose:

  1. docker network inspect nome_da_rede

  2. Exibe detalhes sobre a rede Docker Compose, incluindo os containers conectados e os IPs atribuídos.

• Iniciar um container de forma temporária para testes:

  1. docker run --rm -it ubuntu /bin/bash

  2. Inicia um container Ubuntu de forma temporária com o `–rm`, garantindo que ele seja removido automaticamente após o término da execução.

• Usar volumes com Docker Compose:
  1. Adicionar volumes no `docker-compose.yml`:

```

    version: '3'
    services:
      web:
        image: nginx
        volumes:
          - meu_volume:/var/www/html
    volumes:
      meu_volume:
    ```
  - Utiliza **volumes Docker** com **Docker Compose**, criando um volume chamado **meu_volume** e montando-o no diretório `/var/www/html` do **nginx**.

• Remover imagens antigas de containers não utilizados:

  1. docker image prune

  2. Remove todas as imagens não utilizadas no sistema, liberando espaço.

• Remover containers, volumes e redes de forma automática:

  1. docker system prune

  2. Remove todos os containers, volumes, e redes que não estão em uso, liberando espaço e limpando o ambiente Docker.

• Verificar logs de múltiplos containers com Docker Compose:

  1. docker-compose logs

  2. Exibe os logs de todos os containers gerenciados pelo Docker Compose.