Skip to content

Instantly share code, notes, and snippets.

@rodrigo-galba

rodrigo-galba/gist:3d1996fef7af8bc81b25fc868eb1142d

Last active January 17, 2026 13:23
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save rodrigo-galba/3d1996fef7af8bc81b25fc868eb1142d to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save rodrigo-galba/3d1996fef7af8bc81b25fc868eb1142d to your computer and use it in GitHub Desktop.
Download ZIP
Docker introduction
Raw
gistfile1.md

Introdução: Implantação em contêiners com Docker​

1. Histórico e evolução do Docker

Descrição:

O Docker é uma plataforma de containerização que permite criar, gerenciar e executar aplicações em containers isolados e leves. O Docker foi fundado em 2013 por Solomon Hykes e desde então tem se tornado uma das principais plataformas de containerização do mundo.

Exemplo prático:

docker version 1.12.0-rc2 (build: abc123)

Neste exemplo, você está executando a versão do Docker 1.12.0-rc2 no seu sistema.

2. Benefícios de usar o Docker para gerenciar containers

Descrição:

O Docker oferece várias vantagens ao ser usado para gerenciar containers, incluindo:

  • Isolamento dos ambientes: cada container é isolado e não afeta outros containers ou o sistema operacional.
  • Reutilização de imagens: as imagens podem ser reutilizadas em diferentes projetos.
  • Criação de ambientes de desenvolvimento consistente: os containers podem ser criados com as dependências necessárias para cada projeto.

Exemplo prático:

docker run -it ubuntu /bin/bash

Neste exemplo, você está executando um container do Ubuntu e acessando a shell.

3. Como instalar e configurar o Docker

Descrição:

Para instalar e configurar o Docker, você precisará seguir os seguintes passos:

  • Baixar e instalar o Docker do site oficial.
  • Adicionar o usuário ao grupo de administradores do Docker.
  • Configurar as variáveis de ambiente necessárias.

Exemplo prático:

sudo apt-get update && sudo apt-get install docker.io

Neste exemplo, você está instalando o Docker no sistema Ubuntu.

4. O que é um Dockerfile e como usá-lo

Descrição

O Dockerfile é um arquivo de texto que contém instruções passo a passo para construir uma imagem Docker personalizada. Cada linha representa uma camada da imagem, especificando o que deve ser instalado, copiado ou configurado dentro dela.

Conceito Descrição Exemplo
Dockerfile Arquivo que descreve como construir uma imagem Docker. Dockerfile (sem extensão)
Instrução Cada comando define uma etapa de construção da imagem. FROM, RUN, COPY, CMD
Camadas Cada instrução cria uma camada cacheada, tornando builds mais rápidos. RUN apt-get install gera uma nova camada.
Build da imagem Processo que lê o Dockerfile e cria a imagem final. docker build -t minha-imagem .
Reprodutibilidade Garante que o ambiente será sempre recriado da mesma forma. Usado em CI/CD, deploys e laboratórios.

Exemplo prático

# Escolhe uma imagem base
FROM ubuntu:latest

# Instala o Nginx
RUN apt-get update && apt-get install -y nginx

Explicação das instruções

Instrução Função Exemplo
FROM Define a imagem base a ser usada na construção. FROM python:3.11-slim
RUN Executa comandos no ambiente da imagem. RUN apt-get update
COPY Copia arquivos locais para dentro da imagem. COPY app.py /app/
WORKDIR Define o diretório de trabalho dentro da imagem. WORKDIR /app
CMD Define o comando padrão executado quando o container inicia. CMD ["python", "app.py"]
EXPOSE Indica a porta que o container irá escutar. EXPOSE 80

Comando para criar a imagem

docker build -t nginx-custom .
Parâmetro Descrição
-t nginx-custom Nome (tag) atribuído à imagem gerada.
. Indica o diretório atual onde está o Dockerfile.

Resumo conceitual

Item Resumo
O Dockerfile é o roteiro de construção de uma imagem Docker.
Cada instrução cria camadas reaproveitáveis em builds futuros.
É o ponto de partida para infraestrutura como código no Docker.

5. O que são imagens no Docker?

Descrição

As imagens Docker são modelos imutáveis usados para criar containers. Elas contêm tudo o que é necessário para executar uma aplicação — incluindo o sistema operacional base, bibliotecas, dependências e o código da aplicação.

Conceito Descrição Exemplo
Imagem Modelo que define o que será executado dentro do container. nginx:latest, python:3.11-slim
Camadas (layers) Cada comando no Dockerfile cria uma camada cacheada da imagem. RUN apt-get install nginx gera uma camada nova.
Repositório Local onde as imagens são armazenadas. Pode ser público ou privado. Docker Hub, GHCR, ECR
Tag Identifica a versão da imagem. Se omitida, o Docker usa latest. myapp:1.0, nginx:stable
Imutabilidade Imagens não são alteradas após criadas — novas versões geram novas camadas. docker build -t app:v2 . cria nova imagem.

Exemplo prático

# Lista todas as imagens disponíveis localmente
docker images
Coluna Significado
REPOSITORY Nome da imagem (ex: nginx, ubuntu)
TAG Versão ou identificação da imagem (ex: latest, 3.11)
IMAGE ID Identificador único da imagem
CREATED Quando a imagem foi criada
SIZE Tamanho total da imagem

Resumo conceitual

Item Resumo
As imagens são os modelos base para containers.
Um container é uma instância em execução de uma imagem.
Imagens podem ser baixadas de repositórios (como o Docker Hub) ou criadas localmente via Dockerfile.

6. Como criar uma imagem com o Docker

Descrição:

Para criar uma imagem com o Docker, você precisará seguir os seguintes passos:

  • Criar um Dockerfile que defina as instruções para criar a imagem.
  • Executar o comando docker build para compilar a imagem.

Exemplo prático:

docker build -t myimage .

Neste exemplo, você está criando uma imagem chamada myimage a partir do Dockerfile presente no diretório atual.

7. Laboratório: Criando imagem Nginx com página HTML

Descrição

Neste laboratório, você aprenderá a criar uma imagem Docker baseada no Nginx que servirá uma página HTML personalizada. O objetivo é entender como construir uma imagem simples a partir de uma base Linux, instalar o servidor Nginx e incluir arquivos estáticos.

Exemplo prático:

# Usa uma imagem base do Ubuntu
FROM ubuntu:latest

# Atualiza pacotes e instala o Nginx
RUN apt-get update && apt-get install -y nginx && \
    rm -rf /var/lib/apt/lists/*

# Copia a página HTML personalizada para o diretório padrão do Nginx
COPY index.html /var/www/html/index.html

# Expõe a porta padrão HTTP
EXPOSE 80

# Comando para iniciar o Nginx em primeiro plano (modo não daemon)
CMD ["nginx", "-g", "daemon off;"]

Passos para testar:

  1. Crie um arquivo index.html no mesmo diretório do Dockerfile com o conteúdo desejado, por exemplo:

    <html>
<head><title>Meu Servidor Nginx</title></head>
<body><h1>Olá, Docker!</h1></body>
</html>

  2. Construa a imagem:

    docker build -t nginx-custom .

  3. Execute o container:

    docker run -d -p 8080:80 nginx-custom

  4. Acesse no navegador:

    http://localhost:8080

Explicação

  • FROM ubuntu:latest → usa o Ubuntu como base.
  • RUN apt-get update && apt-get install -y nginx → instala o Nginx.
  • COPY index.html /var/www/html/index.html → copia a página personalizada.
  • EXPOSE 80 → expõe a porta HTTP padrão.
  • CMD ["nginx", "-g", "daemon off;"] → mantém o Nginx rodando em primeiro plano, permitindo que o container continue ativo.

O que são tags e como usá-las

Descrição

As tags são rótulos usados para identificar versões específicas de uma imagem Docker. Elas funcionam como marcadores que ajudam a organizar e versionar suas imagens.

Uso da Tag Descrição Exemplo
latest Tag padrão quando nenhuma é especificada. Representa a versão mais recente. nginx:latest
versão numérica Define uma versão específica da imagem. meuapp:1.0
ambiente Identifica o ambiente de implantação. meuapp:dev, meuapp:prod
data ou build Marca imagens com data/hora ou número de build. meuapp:2025-10-17, meuapp:build45
customizada Pode indicar variantes específicas (GPU, debug, etc). meuapp:gpu, meuapp:debug

Exemplo prático

# Cria uma imagem com tag específica
docker build -t meuapp:1.0 .

# Lista as imagens locais
docker images

# Executa o container com a tag especificada
docker run -d -p 8080:80 meuapp:1.0

Explicação

  • -t meuapp:1.0 → define o nome e a tag da imagem.

  • latest é usado automaticamente se nenhuma tag for informada.

  • Tags podem ser renomeadas ou duplicadas com docker tag:

    docker tag meuapp:1.0 meuapp:latest

Boas práticas

  • Sempre usar tags explícitas em produção.
  • Adotar versionamento semântico (v1.0.0, v1.1.2).
  • Evitar usar apenas latest para implantações automatizadas.

Aqui está o exercício 11 corrigido e completo, com um Dockerfile funcional e explicação revisada para manter clareza e boas práticas:

7.2. Laboratório: Criando imagem Python com Flask

Descrição

Neste laboratório, você aprenderá a criar uma imagem Docker do Python contendo um aplicativo Flask personalizado. O objetivo é entender como construir uma imagem leve com dependências específicas, preparando o ambiente para execução de aplicações web em containers.

Caso de uso

Um caso comum é a necessidade de criar ambientes de desenvolvimento consistentes entre diferentes equipes ou ambientes (dev, staging, prod). Com o Docker, é possível empacotar o código-fonte, dependências e runtime Python em uma imagem isolada e reprodutível.

Exemplo prático

# Usa uma imagem oficial do Python
FROM python:3.11-slim

# Define o diretório de trabalho dentro do container
WORKDIR /app

# Copia o arquivo principal da aplicação
COPY app.py .

# Instala o Flask
RUN pip install --no-cache-dir flask

# Expõe a porta que o Flask utilizará
EXPOSE 5000

# Comando padrão para iniciar a aplicação Flask
CMD ["python", "app.py"]

Arquivo app.py de exemplo

from flask import Flask

app = Flask(__name__)

@app.route("/")
def home():
    return "Olá, Docker + Flask!"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Passos para testar

  1. Crie os arquivos:

    • Dockerfile
    • app.py

  2. Construa a imagem:

    docker build -t flask-app .

  3. Execute o container:

    docker run -d -p 5000:5000 flask-app

  4. Acesse no navegador:

    http://localhost:5000

Explicação

Instrução Função
FROM python:3.11-slim Usa uma imagem base leve do Python 3.11
WORKDIR /app Define o diretório de trabalho dentro do container
COPY app.py . Copia o código da aplicação para o container
RUN pip install flask Instala a dependência Flask
EXPOSE 5000 Indica a porta usada pelo aplicativo
CMD ["python", "app.py"] Executa o app Flask ao iniciar o container

8. O que é o Docker Compose e como utilizá-lo

Descrição

O Docker Compose é uma ferramenta que permite definir, configurar e executar múltiplos containers de forma simples, utilizando um arquivo YAML (docker-compose.yml). Esse arquivo descreve todos os serviços, redes e volumes necessários para que uma aplicação funcione como um todo.

Conceito Descrição Exemplo
Serviço (service) Representa um container configurado (ex: backend, banco de dados). web, db, cache
Rede (network) Permite a comunicação entre containers. frontend, backend
Volume (volume) Armazena dados persistentes fora do ciclo de vida do container. db_data, app_logs
Arquivo YAML Descreve toda a infraestrutura da aplicação de forma declarativa. docker-compose.yml
Comando principal Executa todos os serviços definidos no YAML com um único comando. docker-compose up -d

Caso de uso

Um cenário comum é o desenvolvimento de uma aplicação web completa, composta por vários componentes interdependentes.

Componente Função Exemplo de tecnologia
Backend Processa a lógica da aplicação. Node.js, Python (Flask/Django)
Banco de dados Armazena dados persistentes. PostgreSQL, MySQL
Cache Acelera o acesso a dados temporários. Redis
Servidor web Fornece o conteúdo estático. Nginx

Em vez de criar cada container manualmente com docker run, o Docker Compose permite definir todos esses serviços em um único arquivo YAML e executá-los de uma vez.

Benefícios de usar o Docker Compose

Benefício Descrição
Simplicidade Gerencia múltiplos containers com um único comando.
Centralização Toda a configuração está em um único arquivo (docker-compose.yml).
Reprodutibilidade Garante que o mesmo ambiente possa ser recriado facilmente.
Escalabilidade Permite aumentar o número de réplicas de um serviço (ex: docker-compose up --scale web=3).
Integração Facilita o uso em pipelines CI/CD e ambientes locais de desenvolvimento.

Exemplo prático

version: "3.9"
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: appdb
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:
Comando Descrição
docker-compose up -d Inicia os serviços definidos no arquivo.
docker-compose ps Lista os containers em execução.
docker-compose down Encerra e remove os containers criados.

7.3. Laboratório: Subindo aplicação Flask e PostgreSQL com Docker Compose

Descrição:

Neste laboratório, você aprenderá a executar uma aplicação Python (Flask) conectada a um banco de dados PostgreSQL, utilizando o Docker Compose para orquestrar ambos os containers de forma automatizada.

A ideia é demonstrar como o Docker Compose simplifica a inicialização e o gerenciamento de múltiplos serviços relacionados, simulando um ambiente de desenvolvimento completo.

Estrutura do projeto:

flask-compose-demo/
├── app/
│   ├── Dockerfile
│   └── app.py
└── docker-compose.yml

Passo 1: Criar o aplicativo Flask (app/app.py)

from flask import Flask
import psycopg2
import os

app = Flask(__name__)

@app.route('/')
def index():
    try:
        conn = psycopg2.connect(
            dbname=os.getenv('POSTGRES_DB'),
            user=os.getenv('POSTGRES_USER'),
            password=os.getenv('POSTGRES_PASSWORD'),
            host='db'
        )
        return "Conexão com o banco PostgreSQL estabelecida com sucesso!"
    except Exception as e:
        return f"Erro ao conectar: {e}"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Passo 2: Criar o Dockerfile do Flask (app/Dockerfile)

FROM python:3.9-slim

WORKDIR /app

COPY app.py .

RUN pip install flask psycopg2-binary

EXPOSE 5000

CMD ["python", "app.py"]

Passo 3: Criar o arquivo docker-compose.yml (na raiz do projeto)

services:
  web:
    build: ./app
    ports:
      - "5000:5000"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: flaskdb
    depends_on:
      - db

  db:
    image: postgres:14
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: flaskdb
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Passo 4: Executar o ambiente

No terminal, dentro da pasta do projeto:

docker-compose up

Esse comando:

  • Constrói a imagem da aplicação Flask;
  • Baixa a imagem do PostgreSQL;
  • Cria os dois containers;
  • Configura a rede interna;
  • E inicia o ambiente completo.

Acesse no navegador: http://localhost:5000

Você deverá ver a mensagem:

Conexão com o banco PostgreSQL estabelecida com sucesso!

Passo 5: Encerrar o ambiente

Para encerrar e remover os containers:

docker-compose down

Para também remover volumes e redes criadas:

docker-compose down -v

Benefícios práticos observados:

  • Automação completa de infraestrutura de desenvolvimento.
  • Fácil replicação do ambiente entre diferentes desenvolvedores.
  • Isolamento entre serviços (Flask e PostgreSQL).
  • Reuso de imagens em diversos projetos.

8. Laboratório: Subindo aplicação OpenWeb UI (ChatGPT like) com Docker

Descrição

Neste laboratório, você aprenderá a executar o Open WebUI, uma interface web moderna para modelos de linguagem, usando Docker Compose. O objetivo é compreender como usar o Compose para subir aplicações compostas por múltiplos serviços (backend + frontend) com persistência de dados.

Installing Open WebUI with Bundled Ollama Support - Somente Docker

OpenWeb UI + Ollama

For CPU Only: If you're not using a GPU, use this command instead:

docker run -d -p 3000:8080 -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Executando OpenWebUI com Docker compose

Pré-requisitos

Requisito Descrição
Docker e Docker Compose Devem estar instalados e configurados corretamente.
Porta 3000 livre O Open WebUI será acessado em http://localhost:3000.
Conexão com Ollama (opcional) Caso deseje usar modelos locais como llama3 via Ollama.

Passo 1: Criar o arquivo docker-compose.yml

Crie um diretório para o projeto e adicione o seguinte conteúdo:

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:latest
    container_name: open-webui
    ports:
      - "3000:8080"
    volumes:
      - open-webui-data:/app/backend/data
    environment:
      - WEBUI_AUTH=false   # Opcional: desativa autenticação
      # - OLLAMA_API_BASE=http://host.docker.internal:11434  # se usar Ollama local
    restart: unless-stopped

volumes:
  open-webui-data:

Passo 2: Subir o ambiente

Execute o comando:

docker compose up -d

Isso fará o pull da imagem do GitHub Container Registry e iniciará o serviço do Open WebUI.

Passo 3: Acessar a aplicação

Após alguns segundos, acesse no navegador:

http://localhost:3000

Você deverá ver a interface do Open WebUI, pronta para uso.

Passo 4: Persistência de dados

O volume open-webui-data garante que as configurações, históricos e preferências da interface sejam preservados mesmo após o container ser removido.

Diretório Função
/app/backend/data Armazena as configurações e histórico de uso.

9. Laboratório: Executando o Immich com Docker Compose

Descrição

Neste laboratório, você aprenderá a implantar o Immich de forma simplificada, utilizando apenas os componentes essenciais para armazenar e visualizar fotos/vídeos. Essa configuração é ideal para testes locais, ambientes sem GPU ou máquinas de desenvolvimento.

Immitch App

Arquitetura simplificada

Serviço Função
immich-server Backend principal e API da aplicação.
immich-web Interface web para acessar as fotos e vídeos.
database Armazena metadados e informações do Immich.
redis Cache e controle de tarefas simples.

Pré-requisitos

Requisito Descrição
Docker e Docker Compose Devem estar instalados.
Porta 2283 livre Interface web acessível via http://localhost:2283.
Pelo menos 2 GB de RAM livres Recomendado para evitar falhas no container.

**Passo 1: Crie uma pasta chamada immich-app:

mkdir ./immich-app
cd ./immich-app

Baixe o docker-compose e o arquivo .env:

wget -O docker-compose.yml https://github.com/immich-app/immich/releases/latest/download/docker-compose.yml
wget -O .env https://github.com/immich-app/immich/releases/latest/download/example.env

Passo 2: Subir o ambiente

Execute o comando no terminal:

docker compose up -d

Isso iniciará o backend, o banco de dados, o Redis e a interface web.

Passo 3: Acessar a aplicação

Após a inicialização, abra no navegador:

http://localhost:2283

Na primeira execução, crie um usuário administrador. Você já poderá fazer upload de imagens e navegar na galeria.

Passo 4: Persistência de dados

Volume Descrição
pgdata Armazena os dados do banco PostgreSQL.
immich-data Armazena fotos e vídeos enviados.

Esses volumes garantem persistência mesmo que os containers sejam recriados.

10. Laboratório: Executando o n8n com Docker Compose

Descrição

O n8n é uma ferramenta de automação de fluxos de trabalho (workflow automation), semelhante ao Zapier, mas self-hosted e open source. Com ele, você pode integrar APIs, serviços e aplicações de forma visual, diretamente no navegador.

Arquitetura do laboratório

Serviço Função
n8n Container principal que executa a aplicação web e o motor de workflows.
n8n_data Volume que armazena dados persistentes (workflows, credenciais, logs).

Pré-requisitos

Requisito Descrição
Docker e Docker Compose Devem estar instalados.
Porta 5678 livre A interface web estará disponível em http://localhost:5678.

Passo 1: Criar o arquivo docker-compose.yml

Crie uma pasta chamada n8n-lab e adicione o conteúdo abaixo:

version: "3.9"

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=admin123
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
    volumes:
      - n8n_data:/home/node/.n8n
    restart: unless-stopped

volumes:
  n8n_data:

Passo 2: Subir o container

No terminal, execute:

docker compose up -d

O Docker fará o pull da imagem e iniciará o serviço do n8n.

Passo 3: Acessar a interface

Após alguns segundos, acesse no navegador:

http://localhost:5678

Login padrão:

  • Usuário: admin
  • Senha: admin123

Passo 4: Persistência de dados

Volume Descrição
n8n_data Armazena dados de configuração, credenciais e workflows criados.

Mesmo que o container seja removido, os fluxos permanecerão salvos.

11. Laboratório: Executando o Portainer com Docker Compose

Descrição

O Portainer é uma interface web leve e poderosa para gerenciar containers, imagens, volumes e redes Docker. Ele simplifica o uso do Docker e do Docker Compose, permitindo controlar o ambiente por meio de um painel visual, sem depender de comandos CLI.

Arquitetura do laboratório

Serviço Função
portainer Interface web de gerenciamento do Docker Engine local.
portainer_data Volume persistente onde ficam armazenadas as configurações do Portainer.

Pré-requisitos

Requisito Descrição
Docker e Docker Compose Devem estar instalados.
Porta 9000 livre Interface web estará disponível em http://localhost:9000.
Permissão de acesso ao socket Docker O container precisará se conectar ao daemon Docker local.

Passo 1: Criar o arquivo docker-compose.yml

Crie uma pasta chamada portainer-lab e adicione o seguinte conteúdo:

services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    restart: unless-stopped
    ports:
      - "9000:9000"
      - "9443:9443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data

volumes:
  portainer_data:

Passo 2: Subir o ambiente

Execute no terminal:

docker compose up -d

O Compose fará o download da imagem e iniciará o serviço.

Passo 3: Acessar a interface

Após alguns segundos, abra no navegador:

http://localhost:9000

Na primeira execução:

  • Crie um usuário administrador (ex: admin / senha segura).
  • Selecione a opção “Docker local” para gerenciar o Docker Engine do próprio host.

Passo 4: Persistência de dados

Volume Descrição
portainer_data Armazena usuários, stacks e configurações do painel.

Mesmo após reiniciar o container, as configurações permanecerão salvas.

12. Laboratório: Executando o Dockpeek com Docker Compose

Descrição

O Dockpeek é uma ferramenta web open source para visualizar e gerenciar containers Docker de forma simples e rápida. Ele oferece uma interface leve para inspecionar containers, imagens, volumes e logs, sem a complexidade de soluções mais robustas como o Portainer.

Arquitetura do laboratório

Serviço Função
dockpeek Interface web para inspecionar containers Docker em tempo real.
/var/run/docker.sock Socket usado para comunicação direta com o Docker Engine local.

Pré-requisitos

Requisito Descrição
Docker e Docker Compose Devem estar instalados.
Porta 5001 livre A interface web estará acessível em http://localhost:5001.
Permissão para montar o socket Docker Necessário para acessar o daemon Docker local.

Passo 1: Criar o arquivo docker-compose.yml

Crie uma pasta chamada dockpeek-lab e adicione o conteúdo abaixo:

services:
  dockpeek:
    image: dockpeek/dockpeek:latest
    container_name: dockpeek
    environment:
      - SECRET_KEY=your_secure_secret_key # Required: Set a secure secret key
      - USERNAME=admin # username
      - PASSWORD=secure_password # password
    ports:
      - "3420:8000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    restart: unless-stopped

Passo 2: Subir o ambiente

Execute no terminal:

docker compose up -d

O Compose fará o download da imagem do GitHub Container Registry e iniciará o serviço Dockpeek.

Passo 3: Acessar a interface

Após a inicialização, abra no navegador:

http://localhost:5001

Você verá o painel do Dockpeek, onde é possível:

  • Listar containers em execução.
  • Inspecionar logs, redes e volumes.
  • Ver detalhes das imagens locais.

Passo 4: Persistência e segurança

Recurso Descrição
/var/run/docker.sock Permite que o Dockpeek se comunique diretamente com o Docker Engine local.
restart: unless-stopped Garante que o serviço reinicie automaticamente após reboot.

Nota: Por questões de segurança, evite expor o Dockpeek publicamente sem autenticação ou proxy reverso. Ele foi projetado para uso local e administrativo.

Resumo

Aqui estão as 10 perguntas sobre Docker, Dockerfile, Container, Image, Tag e Registry:

1. O que é Docker? a) Uma linguagem de programação b) Um sistema de gerenciamento de conteúdo c) Uma plataforma de containerização para desenvolvimento e produção d) Uma ferramenta de segurança

2. Qual é o propósito do Dockerfile? a) Criar uma imagem Docker b) Executar um comando no shell c) Definir as configurações de um contêiner Docker d) Excluir uma imagem Docker

3. O que é um Container? a) Uma instância isolada do sistema operacional b) Uma ferramenta de segurança para proteger dados sensíveis c) Uma aplicação Web desenvolvida em PHP d) Um serviço de hospedagem de arquivos

4. Qual é o propósito da Tag em Docker? a) Identificar uma imagem Docker específica b) Executar um comando no shell c) Definir as configurações de um contêiner Docker d) Excluir uma imagem Docker

5. O que é o Registry em Docker? a) Uma loja de imagens Docker onde você pode armazenar e compartilhar imagens b) Uma ferramenta de segurança para proteger dados sensíveis c) Uma aplicação Web desenvolvida em Python d) Um serviço de hospedagem de arquivos

6. Como posso criar uma imagem Docker? a) Utilizando o comando docker build b) Utilizando o comando docker run c) Utilizando o comando docker exec d) Utilizando o comando docker rm

7. Qual é o propósito do comando docker ps? a) Exibir as imagens Docker existentes b) Exibir os contêiners Docker existentes e seu estado c) Executar um comando no shell d) Excluir uma imagem Docker

8. Como posso excluir uma imagem Docker? a) Utilizando o comando docker rm b) Utilizando o comando docker rmi c) Utilizando o comando docker exec d) Utilizando o comando docker ps

9. Qual é o propósito do comando docker pull? a) Baixar uma imagem Docker de um repositório remoto b) Executar um comando no shell c) Definir as configurações de um contêiner Docker d) Excluir uma imagem Docker

10. Como posso compartilhar uma imagem Docker? a) Utilizando o comando docker push b) Utilizando o comando docker pull c) Utilizando o comando docker exec d) Utilizando o comando docker rm

Respostas:

  1. c) Uma plataforma de containerização para desenvolvimento e produção: Docker é uma plataforma de containerização que permite criar, executar e compartilhar aplicações em contêineres isolados. Isso facilita a depuração, testagem e implantação de aplicativos.

  2. c) Definir as configurações de um contêiner Docker: O arquivo Dockerfile é utilizado para especificar as etapas necessárias para criar uma imagem Docker. Ele define como os pacotes, bibliotecas e dependências devem ser configurados no contêiner.

  3. a) Uma instância isolada do sistema operacional: Um contêiner em Docker é uma instância isolada do sistema operacional que permite executar aplicações de forma independente. Isso significa que cada contêiner tem seu próprio espaço de memória, arquivos e processos.

  4. a) Identificar uma imagem Docker específica: A tag é utilizada para identificar uma imagem Docker específica em um repositório remoto ou local. Ela pode ser usada para especificar a versão da imagem que deseja baixar ou utilizar.

  5. a) Uma loja de imagens Docker onde você pode armazenar e compartilhar imagens: O registry é uma plataforma que permite armazenar, compartilhar e gerenciar imagens Docker em nuvem. Isso facilita a reutilização de imagens entre diferentes projetos ou equipes.

  6. a) Utilizando o comando docker build: O comando docker build é utilizado para criar uma imagem Docker a partir do arquivo Dockerfile e dos arquivos necessários (como pacotes, bibliotecas e dependências).

  7. b) Exibir os contêiners Docker existentes e seu estado: O comando docker ps é utilizado para exibir os contêineres atuais em execução, bem como informações sobre seus status (por exemplo, se estão executando ou parados).

  8. b) Utilizando o comando docker rmi: O comando docker rmi é utilizado para remover uma imagem Docker a partir do seu repositório local.

  9. a) Baixar uma imagem Docker de um repositório remoto: O comando docker pull é utilizado para baixar uma imagem Docker específica do registry remoto e armazená-la no repositório local.

  10. a) Utilizando o comando docker push: O comando docker push é utilizado para compartilhar uma imagem Docker com outros usuários ou equipes por meio da plataforma de registry em nuvem. Isso permite que outras pessoas acessem e utilizem as imagens armazenadas no seu repositório remoto.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment