📦 Docker - Serviços Utilizados

Documentação dos principais serviços utilizados com Docker, com comandos prontos para facilitar a implantação.

📦 Documentação Docker (clique para expandir)

Documentação dos principais serviços utilizados com Docker, com comandos prontos para facilitar a implantação.

---

🚀 Portainer (clique para expandir)

Gerenciador gráfico de containers Docker.

docker volume create portainer_data

docker run -d \
  -p 8000:8000 \
  -p 9443:9443 \
  --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:lts

---

📘 MkDocs (clique para expandir)

Plataforma para documentação com tema Material Design.

📁 Estrutura de diretórios

mkdir /mkdocs-documentos
mkdir /root/mkdocs/

🐳 Dockerfile

Crie o arquivo:

nano /root/mkdocs/Dockerfile

Conteúdo:

FROM python:3.12
RUN apt-get update && apt-get install -y \
    git \
    curl \
    && apt-get clean && rm -rf /var/lib/apt/lists/*
RUN pip install --upgrade pip && \
    pip install --upgrade \
        mkdocs \
        mkdocs-material \
        mkdocs-mermaid2-plugin \
        mkdocs-video \
        mkdocs-swan \
        mkdocs-encryptcontent-plugin \
        pymdown-extensions \
        mkdocs-git-revision-date-localized-plugin
WORKDIR /docs
EXPOSE 8800
CMD ["mkdocs", "serve", "--dev-addr=0.0.0.0:8800"]

---

🧩 docker-compose.yml

nano docker-compose.yml

Conteúdo:

version: "3"

services:
  mkdocs:
    build: .
    container_name: mkdocs-server
    volumes:
      - /mkdocs-documentos:/docs
    ports:
      - "8800:8800"
    restart: unless-stopped

▶️ Iniciar

docker compose build --no-cache
docker compose up -d

---

💾 Backup dos dados MkDocs (clique para expandir)

nano /backup_mkdocs.sh

📄 Clique aqui para ver o script de backup

#!/bin/bash

SOURCE_DIR="/mkdocs-documentos"
BACKUP_NAME="mkdocs_backup_$(date +%F_%H-%M-%S).tar.gz"
TELEGRAM_BOT_TOKEN="6307490274:AAGx5q-tQAP-HeAUGbAOo4XVJSlbtLCkpEA"
TELEGRAM_CHAT_ID="-4505537919"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

send_telegram_message() {
    local MSG="$1"
    curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
        -d chat_id="${TELEGRAM_CHAT_ID}" \
        -d text="${MSG}" > /dev/null
}

if [ ! -d "$SOURCE_DIR" ]; then
    log "❌ Diretório $SOURCE_DIR não encontrado!"
    send_telegram_message "❌ Diretório *$SOURCE_DIR* não encontrado para backup do MkDocs."
    exit 1
fi

log "📦 Compactando $SOURCE_DIR..."
tar -czf "$BACKUP_NAME" -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")"

if [ $? -eq 0 ]; then
    log "✅ Backup criado com sucesso: $BACKUP_NAME"

    log "📤 Enviando para o Telegram..."
    curl -s -F document=@"$BACKUP_NAME" \
        "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendDocument?chat_id=${TELEGRAM_CHAT_ID}" > /dev/null

    if [ $? -eq 0 ]; then
        log "✅ Backup enviado com sucesso!"
        rm -f "$BACKUP_NAME"
        log "🧹 Backup local removido."
    else
        log "❌ Erro ao enviar para o Telegram."
        send_telegram_message "⚠️ Backup do *MkDocs* criado, mas falhou o envio para o Telegram."
    fi
else
    log "❌ Erro ao criar backup do MkDocs."
    send_telegram_message "❌ Erro ao criar backup do diretório *$SOURCE_DIR*."
fi

🔁 Agendar backup

chmod +x /backup_mkdocs.sh
./backup_mkdocs.sh

crontab -e
# Executa toda segunda-feira às 03:00
0 3 * * 1 /backup_mkdocs.sh

---

🔁 Convoy - Gerenciamento de VPS (clique para expandir)

Página do projeto: https://convoypanel.com/

curl -fsSL https://get.docker.com/ | sh
mkdir -p /var/www/convoy
cd /var/www/convoy

curl -Lo panel.tar.gz https://github.com/convoypanel/panel/releases/latest/download/panel.tar.gz
tar -xzvf panel.tar.gz
chmod -R o+w storage/* bootstrap/cache/

---

🌐 NGINX Proxy Manager (clique para expandir)

Gerenciador de proxies reversos com suporte a SSL, sem banco de dados.

nano /etc/nginx-proxy/docker-compose.yml

Conteúdo:

services:
  app:
    image: 'docker.io/jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      - '80:80'
      - '81:81'
      - '443:443'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt

▶️ Iniciar

docker compose up -d

Acesse via navegador:

http://SEU-IP:81

Credenciais padrão:

Email: admin@example.com
Senha: changeme

---

📊 Uptime Kuma (clique para expandir)

Monitoramento de serviços com painel web.

docker run -d --restart=always \
  -p 3001:3001 \
  -v uptime-kuma:/app/data \
  --name uptime-kuma \
  louislam/uptime-kuma:1

---

📡 SRS - Simple Realtime Server (clique para expandir)

Servidor RTMP e WebRTC para streaming.

docker run -d \
  --name srs-server \
  -p 1935:1935 -p 1985:1985 -p 8080:8080 \
  -p 8000:8000/udp -p 10080:10080/udp \
  ossrs/srs:5

---

📦 Ambiente Local do NetBox com Docker (clique para expandir)

Este documento descreve o ambiente leve de testes do NetBox utilizando Docker Compose, com PostgreSQL + Redis, ideal para uso local ou laboratórios.

Download do backup mais recente

🛠️ Estrutura dos Containers

Container	Função
netbox-app	Aplicação NetBox (Gunicorn)
netbox-db	Banco PostgreSQL
netbox-redis	Cache e fila de tarefas

🚀 Requisitos

• Docker
• Docker Compose
• (Opcional) openssl para gerar SECRET_KEY

📁 Estrutura de pastas esperada

mkdir -p netbox/{netbox-config,netbox-media,netbox-reports,netbox-scripts,postgres-data} \
&& touch netbox/docker-compose.yml \
&& touch netbox/netbox-config/configuration.py

netbox/
├── docker-compose.yml
├── netbox-config/
│   └── configuration.py
├── netbox-media/
├── netbox-reports/
├── netbox-scripts/
├── postgres-data/

⚙️ docker-compose.yml

version: '3.4'

services:
  netbox-db:
    image: postgres:15-alpine
    container_name: netbox-db
    environment:
      POSTGRES_DB: netbox
      POSTGRES_USER: netbox
      POSTGRES_PASSWORD: netbox
    volumes:
      - ./postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

  netbox-redis:
    image: redis:alpine
    container_name: netbox-redis
    restart: unless-stopped

  netbox-app:
    image: netboxcommunity/netbox:latest
    container_name: netbox-app
    depends_on:
      - netbox-db
      - netbox-redis
    ports:
      - "8030:8080"
    environment:
      - DB_NAME=netbox
      - DB_USER=netbox
      - DB_PASSWORD=netbox
      - DB_HOST=netbox-db
      - REDIS_HOST=netbox-redis
      - ALLOWED_HOSTS=*
      - SUPERUSER_NAME=admin
      - SUPERUSER_EMAIL=admin@example.com
      - SUPERUSER_PASSWORD=admin123
    volumes:
      - ./netbox-media:/opt/netbox/netbox/media
      - ./netbox-reports:/opt/netbox/netbox/reports
      - ./netbox-scripts:/opt/netbox/netbox/scripts
      - ./netbox-config:/etc/netbox/config
    restart: unless-stopped

🧬 netbox-config/configuration.py

SECRET_KEY = 'troque-por-uma-chave-secreta'
ALLOWED_HOSTS = ['*']

DATABASE = {
    'ENGINE': 'django.db.backends.postgresql',
    'NAME': 'netbox',
    'USER': 'netbox',
    'PASSWORD': 'netbox',
    'HOST': 'netbox-db',
    'PORT': '',
}

REDIS = {
    'tasks': {
        'HOST': 'netbox-redis',
        'PORT': 6379,
        'DB': 0,
        'PASSWORD': '',
    },
    'caching': {
        'HOST': 'netbox-redis',
        'PORT': 6379,
        'DB': 1,
        'PASSWORD': '',
    }
}

🔐 Gere uma chave com:

openssl rand -hex 32

💾 Script de Backup do Banco de Dados

Crie um script chamado backup-netbox.sh com o seguinte conteúdo:

#!/bin/bash

# Configurações
BACKUP_DIR="/mkdocs-documentos/docs/backups/netbox"
DATE=$(date +"%Y-%m-%d_%H-%M-%S")
BACKUP_NAME="netbox-backup-${DATE}.tar.gz"
LATEST="$BACKUP_DIR/netbox-latest.tar.gz"

TELEGRAM_BOT_TOKEN="6307490274:AAGx5q-tQAP-HeAUGbAOo4XVJSlbtLCkpEA"
TELEGRAM_CHAT_ID="-4505537919"

# Cria diretório se não existir
mkdir -p "$BACKUP_DIR"

# Dump do banco
echo "🎯 Gerando dump do banco PostgreSQL..."
docker exec netbox-db pg_dump -U netbox netbox > /tmp/netbox.sql

# Compacta tudo
echo "📦 Compactando arquivos..."
tar -czf "$BACKUP_DIR/$BACKUP_NAME" \
    /tmp/netbox.sql \
    /root/netbox/docker-compose.yml \
    /root/netbox/netbox-media \
    /root/netbox/netbox-reports \
    /root/netbox/netbox-scripts \
    /root/netbox/netbox-config/configuration.py

# Atualiza o backup mais recente
cp "$BACKUP_DIR/$BACKUP_NAME" "$LATEST"

# Limpeza do arquivo temporário
rm -f /tmp/netbox.sql

# Retenção (mantém os 5 mais recentes, exceto latest)
ls -1t "$BACKUP_DIR"/netbox-backup-*.tar.gz | grep -v "netbox-latest.tar.gz" | tail -n +6 | xargs -r rm -f

# Tamanho do backup
SIZE=$(du -h "$BACKUP_DIR/$BACKUP_NAME" | cut -f1)

# Envia mensagem para o Telegram (formatação correta)
curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
    -d chat_id="${TELEGRAM_CHAT_ID}" \
--data-urlencode "text=✅ *Backup do NetBox concluído com sucesso!*
🗃️ Arquivo: \`$BACKUP_NAME\`
📦 Tamanho: *$SIZE*" \
-d parse_mode="Markdown" > /dev/null

echo "✅ Backup finalizado: $BACKUP_NAME ($SIZE)"

Torne o script executável:

chmod +x backup-netbox.sh

Agende a execução automática com crontab:

0 2 * * * /backup-netbox.sh

O arquivo mais recente estará sempre disponível no caminho:

/mkdocs-documentos/docs/backups/netbox/netbox-latest.sql

🔧 Primeira execução

docker compose up -d

Ao iniciar o container, automaticamente o netbox fara a importação das tabelas, isso leva um tempo, pode ser acompanhado com o comando a baixo

docker logs -f netbox-app

Depois de iniciado, crie um usuário admin:

docker exec -it netbox-app /opt/netbox/venv/bin/python /opt/netbox/netbox/manage.py createsuperuser

🌐 Acesso

• URL: http://localhost:8000
• Usuário: conforme criado no passo anterior

---

🧹 Resetando ambiente (opcional)

docker compose down -v
rm -rf postgres-data

---

✅ Pronto!

Você agora tem um ambiente leve e funcional do NetBox para testes e demonstrações locais.