feat: Add complete Docker and Portainer documentation (Level 0-3) and fix PDF script table rendering

2026-01-25 03:18:44 -03:00 · 2026-01-25 03:18:44 -03:00 · 34aa30ad3e
parent 96e9f6e60f
commit 34aa30ad3e
21 changed files with 931 additions and 9 deletions
--- a/.gemini/convert_to_pdf.py
+++ b/.gemini/convert_to_pdf.py
@ -294,7 +294,7 @@ def convert(md_file, pdf_file):
                pdf.set_draw_color(*COLOR_PRIMARY)
                pdf.set_line_width(0.3)
-                is_tech_data = "Campo" in headers[0] or "Valor" in headers[1] 
+                is_tech_data = ("Campo" in headers[0] or "Valor" in headers[1]) and len(headers) == 2
                col_widths = (30, 70) if is_tech_data else None
                with pdf.table(
--- a/.gemini/manual_registry.json
+++ b/.gemini/manual_registry.json
@ -1,6 +1,6 @@
 {
  "ITGCLI": {
-    "next_id": 3,
+    "next_id": 4,
    "manuals": [
      {
        "code": "ITGCLI 0001/26",
@ -15,11 +15,18 @@
        "title": "Como Configurar Resposta Automatica de Ferias",
        "created_at": "2026-01-23 00:28:23",
        "author": "Agente iT Guys"
      },
      {
        "code": "ITGCLI 0003/26",
        "id": 3,
        "title": "Docker para Desenvolvedores e Ferramentas Portáteis",
        "created_at": "2026-01-25 03:15:50",
        "author": "João Pedro Toledo Gonçalves"
      }
    ]
  },
  "ITGSUP": {
-    "next_id": 7,
+    "next_id": 10,
    "manuals": [
      {
        "code": "ITGSUP 0001/26",
@ -62,11 +69,32 @@
        "title": "N1_03_Monitoramento_Basico",
        "created_at": "2026-01-23 00:28:41",
        "author": "Agente iT Guys"
      },
      {
        "code": "ITGSUP 0007/26",
        "id": 7,
        "title": "Instalação e Configuração do Docker e Compose (Linux)",
        "created_at": "2026-01-25 03:08:42",
        "author": "João Pedro Toledo Gonçalves"
      },
      {
        "code": "ITGSUP 0008/26",
        "id": 8,
        "title": "Deploy do Portainer CE (Docker Standalone)",
        "created_at": "2026-01-25 03:12:14",
        "author": "João Pedro Toledo Gonçalves"
      },
      {
        "code": "ITGSUP 0009/26",
        "id": 9,
        "title": "Gestão de Stacks no Portainer",
        "created_at": "2026-01-25 03:12:16",
        "author": "João Pedro Toledo Gonçalves"
      }
    ]
  },
  "ITGINF": {
-    "next_id": 9,
+    "next_id": 12,
    "manuals": [
      {
        "code": "ITGINF 0001/26",
@ -123,11 +151,32 @@
        "title": "N2_04_Troubleshooting",
        "created_at": "2026-01-23 00:28:45",
        "author": "Agente iT Guys"
      },
      {
        "code": "ITGINF 0009/26",
        "id": 9,
        "title": "Redes e Firewall no Docker",
        "created_at": "2026-01-25 03:10:05",
        "author": "João Pedro Toledo Gonçalves"
      },
      {
        "code": "ITGINF 0010/26",
        "id": 10,
        "title": "Volumes e Persistência de Dados no Docker",
        "created_at": "2026-01-25 03:11:09",
        "author": "João Pedro Toledo Gonçalves"
      },
      {
        "code": "ITGINF 0011/26",
        "id": 11,
        "title": "Healthchecks e Scripts Automatizados no Docker",
        "created_at": "2026-01-25 03:13:50",
        "author": "João Pedro Toledo Gonçalves"
      }
    ]
  },
  "ITGENG": {
-    "next_id": 14,
+    "next_id": 16,
    "manuals": [
      {
        "code": "ITGENG 0001/26",
@ -219,6 +268,20 @@
        "title": "N3_04_DR_Arquitetura",
        "created_at": "2026-01-23 00:28:49",
        "author": "Agente iT Guys"
      },
      {
        "code": "ITGENG 0014/26",
        "id": 14,
        "title": "Docker Swarm: Inicialização e Gerenciamento",
        "created_at": "2026-01-25 03:13:48",
        "author": "João Pedro Toledo Gonçalves"
      },
      {
        "code": "ITGENG 0015/26",
        "id": 15,
        "title": "Kubernetes: Visão Geral e Ferramentas Básicas",
        "created_at": "2026-01-25 03:13:49",
        "author": "João Pedro Toledo Gonçalves"
      }
    ]
  }
--- a/README.md
+++ b/README.md
@ -86,10 +86,15 @@ Este repositório contém a documentação técnica da iT Guys, organizada por s
 - [ ] [Nível 3] Troubleshooting de Rede
 ### 7. Conteineres (Docker / Portainer)
- [ ] [Nível 1] Deploy e Update de Stacks
+- [x] [Nível 0] Docker para Devs e Ferramentas
- [ ] [Nível 2] Diagnóstico de Containers
+- [x] [Nível 1] Instalação e Configuração (Docker + Compose)
- [ ] [Nível 2] Manutenção de Disco (Prune)
+- [x] [Nível 1] Deploy Portainer CE
- [ ] [Nível 3] Backup de Volumes
+- [x] [Nível 1] Gestão de Stacks (Manual/GitOps)
 - [x] [Nível 2] Redes e Firewall
 - [x] [Nível 2] Volumes e Persistência de Dados
 - [x] [Nível 2] Healthchecks e Cron
 - [x] [Nível 3] Docker Swarm: Inicialização e Gerenciamento
 - [x] [Nível 3] Kubernetes: Visão Geral e Ferramentas Básicas
 ### 8. Linux Server
 - [x] [Nível 1] Comandos Essenciais de Diagnóstico
--- a/conteineres/Nivel_0/Docker_para_Desenvolvedores.md
+++ b/conteineres/Nivel_0/Docker_para_Desenvolvedores.md
@ -0,0 +1,89 @@
 # MANUAL TÉCNICO - DOCKER PARA DESENVOLVEDORES E FERRAMENTAS PORTÁTEIS
 **Código:** ITGCLI 0003/26 | **Classificação:** PÚBLICO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Ensinar o desenvolvedor a usar o Docker para rodar ferramentas, bancos de dados e linguagens sem "sujar" o sistema operacional principal, resolvendo o problema de "Na minha máquina funciona".
 ## 3. PRÉ-REQUISITOS
 - [ ] Docker Desktop (Windows/Mac) ou Engine (Linux) instalado.
 ## 4. CONCEITOS (POR QUE ISSO EXISTE?)
 *   **Efêmero (`--rm`):** O container nasce, executa e se autodestrói. Zero lixo no disco.
 *   **Portátil:** Se roda no seu Docker, roda no servidor de produção.
 ## 5. PASSO A PASSO (EXECUÇÃO)
 **Cenário A: Rodando Ferramentas sem Instalar Nada**
 > Imagine que você precisa testar um script Python ou Node.js, mas não quer instalar versões específicas na sua máquina.
 1.  Rode um script Python (One-off):
    ```bash
    # Monta a pasta atual (.) em /app e roda o script
    docker run --rm -v $(pwd):/app -w /app python:3.9 python meu_script.py
    ```
    *   `--rm`: Remove o container ao terminar.
    *   `-v`: Disponibiliza seus arquivos locais dentro do container.
 2.  Acesse um terminal Node.js limpo:
    ```bash
    docker run --rm -it node:18 /bin/bash
    ```
 **Cenário B: Banco de Dados de Desenvolvimento**
 > Suba um banco Postgres em segundos, use, e destrua.
 1.  Comando rápido (Oneliner):
    ```bash
    docker run --rm --name meupostgres -e POSTGRES_PASSWORD=secret -p 5432:5432 postgres:15
    ```
    *   Acesse via DBeaver/PgAdmin em `localhost:5432`.
 **Cenário C: Ambiente Completo com Compose**
 > A melhor forma de padronizar o time. Crie um `docker-compose.yaml` na raiz do projeto.
 ```yaml
 version: '3.8'
 services:
  app:
    build: .
    ports: ["3000:3000"]
    volumes:
      - .:/code  # Hot-reload: altera no host, reflete no container
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: root
    ports: ["5432:5432"]
 ```
 1.  Para iniciar tudo:
    ```bash
    docker compose up
    ```
 ## 6. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: "Works on my machine" ainda acontece**
 *   **Causa:** Você está usando volumes (`-v`) que trazem arquivos de config do seu PC para dentro do container.
 *   **Solução:** Use `.dockerignore` para não copiar arquivos `node_modules` ou `.env` locais durante o build.
 **Problema 2: Porta ocupada**
 *   **Causa:** Você já tem um Postgres instalado no Windows Services.
 *   **Solução:** Pare o serviço local ou mude a porta do container: `-p 5433:5432`.
 ## 7. VALIDAÇÃO FINAL
 - [ ] Consegue rodar `docker run --rm hello-world` e ele some depois (`docker ps -a`)?
 - [ ] Seu time consegue rodar `docker compose up` e ter o ambiente rodando sem configurar nada?
--- a/conteineres/Nivel_0/Docker_para_Desenvolvedores.pdf
+++ b/conteineres/Nivel_0/Docker_para_Desenvolvedores.pdf
--- a/conteineres/Nivel_1/Deploy_Portainer_CE.md
+++ b/conteineres/Nivel_1/Deploy_Portainer_CE.md
@ -0,0 +1,83 @@
 # MANUAL TÉCNICO - DEPLOY E ACESSO AO PORTAINER CE
 **Código:** ITGSUP 0008/26 | **Classificação:** RESTRITO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Instalar o Portainer CE (Community Edition) para gerenciamento visual de conteineres, imagens e redes, utilizando a instalação via Docker STANDALONE (Não Swarm).
 ## 3. PRÉ-REQUISITOS
 - [ ] Docker Engine instalado e rodando.
 - [ ] Porta 9443 liberada no Firewal do Host.
 - [ ] Acesso root/sudo.
 ## 4. PASSO A PASSO (EXECUÇÃO)
 **Etapa 1: Persistência de Dados**
 1.  Crie o volume para salvar as configurações do Portainer.
 ```bash
 docker volume create portainer_data
 ```
 **Etapa 2: Deploy do Container**
 > 🚀 **DICA:** O Portainer precisa de acesso ao socket do Docker (`/var/run/docker.sock`) para controlar o host.
 1.  Execute o comando oficial de instalação:
 ```bash
 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:latest
 ```
 **Etapa 3: Acesso e Configuração Inicial**
 1.  Abra o navegador e acesse: `https://{{IP_SERVIDOR}}:9443`.
 2.  A tela **"New Portainer Installation"** será exibida.
 > [!IMPORTANT]
 > Se você demorar mais de 5 minutos, o Portainer desativa o setup por segurança. Reinicie o container com `docker restart portainer` se isso ocorrer.
 3.  **Preencha os campos:**
    *   **Username:** `admin` (ou outro de sua escolha)
    *   **Password:** Crie uma senha forte (mínimo 12 caracteres).
    *   **Allow collection of anonymous statistics:** Opcional (Recomendado desmarcar em produção).
 4.  Clique em **Create user**.
 **Etapa 4: Conectando ao Ambiente Local**
 1.  Após o login, clique em **"Get Started"** na opção **Local**.
 2.  Você verá a dashboard principal com a lista de Stacks, Containers e Imagens.
 ## 5. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: "Client sent an HTTP request to an HTTPS server"**
 *   **Causa:** Tentar acessar via `http://` na porta 9443.
 *   **Solução:** Sempre use `https://`. (Aceite o aviso de certificado auto-assinado).
 **Problema 2: "Error response from daemon: bind: address already in use"**
 *   **Causa:** Porta 9443 ou 8000 já ocupada.
 *   **Solução:**
    1.  Verifique quem usa a porta: `sudo lsof -i :9443`.
    2.  Altere o mapeamento no run: `-p 9444:9443`.
 ## 6. DADOS TÉCNICOS
 | Campo | Valor | Descrição |
 | :--- | :--- | :--- |
 | **Imagem Oficial** | `portainer/portainer-ce:latest` | Use sempre a CE, não a Business (salvo se tiver licença) |
 | **Porta HTTPS** | `9443` | Acesso Web seguro |
 | **Volume** | `portainer_data` | Dados do banco interno BoltDB |
 ## 7. VALIDAÇÃO FINAL
 - [ ] A URL `https://IP:9443` abre a tela de login?
 - [ ] O container `portainer` está com status "Up" (`docker ps`)?
 - [ ] O login funciona e mostra o ambiente "local"?
--- a/conteineres/Nivel_1/Deploy_Portainer_CE.pdf
+++ b/conteineres/Nivel_1/Deploy_Portainer_CE.pdf
--- a/conteineres/Nivel_1/Gestao_Stacks_Portainer.md
+++ b/conteineres/Nivel_1/Gestao_Stacks_Portainer.md
@ -0,0 +1,77 @@
 # MANUAL TÉCNICO - GESTÃO DE STACKS NO PORTAINER
 **Código:** ITGSUP 0009/26 | **Classificação:** RESTRITO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Padronizar o deploy de aplicações (Stacks) no Portainer utilizando três métodos: Upload Manual, Templates de App e Repositório Git (GitOps Básico).
 ## 3. PRÉ-REQUISITOS
 - [ ] Portainer instalado e acessível.
 - [ ] Um arquivo `docker-compose.yml` válido E/OU Uma URL de repositório Git (GitHub/GitLab).
 ## 4. PASSO A PASSO (EXECUÇÃO)
 **Etapa 1: Deploy via Web Editor (Rápido)**
 1.  No menu lateral, clique em **Stacks** -> **Add stack**.
 2.  Selecione a opção **Web editor**.
 3.  **Name:** Dê um nome único (ex: `meu-nginx`).
 4.  Cole o conteúdo do seu `docker-compose.yml` na área de texto.
 5.  Clique em **Deploy the stack**.
 **Etapa 2: Deploy via App Templates (Iniciantes)**
 1.  No menu lateral, clique em **App Templates**.
 2.  Selecione uma aplicação pronta (ex: "Wordpress" ou "Nginx").
 3.  Preencha os campos (Nome, Senha do Banco).
 4.  Clique em **Deploy the stack**.
 **Etapa 3: Deploy via Repositório Git (Recomendado/GitOps)**
 > 🚀 **MELHOR PRÁTICA:** Permite versionamento e "Single Source of Truth".
 1.  Vá em **Stacks** -> **Add stack**.
 2.  Selecione **Git Repository**.
 3.  **Configuração:**
    *   **Repository URL:** `https://github.com/usuario/repo.git`
    *   **Repository Reference:** `main` (ou `refs/heads/main`).
    *   **Compose path:** `docker-compose.yml` (se estiver na raiz).
 4.  **Authentication (Se privado):**
    *   Ative "Authentication".
    *   Use seu Username e, preferencialmente, um **Personal Access Token** (não sua senha).
 5.  Ative **Automatic updates** (Opcional) para polling.
 6.  Clique em **Deploy the stack**.
 **Etapa 4: Edição e Updates**
 *   **Web Editor:** Clique na stack -> Editor -> Update the stack.
 *   **Git:** Faça o commit no Git -> No Portainer, clique em **"Pull and redeploy"** (ou aguarde o Auto-update).
 ## 5. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: "Deployment error: Stack already exists"**
 *   **Causa:** Já existe uma stack com esse nome (mesmo que parada).
 *   **Solução:** Delete a stack antiga ou use outro nome.
 **Problema 2: "Authentication failed" no Git**
 *   **Causa:** Senha incorreta ou uso de senha ao invés de Token (GitHub exige Token).
 *   **Solução:** Gere um PAT (Personal Access Token) no GitHub (Settings -> Developer Settings) e use como senha.
 ## 6. DADOS TÉCNICOS
 | Campo | Valor | Descrição |
 | :--- | :--- | :--- |
 | **Padrão** | `docker-compose.yml` | Formato obrigatório |
 | **Limit** | `Stack` | Equivalente a um projeto Docker Compose |
 ## 7. VALIDAÇÃO FINAL
 - [ ] A stack aparece com status "Active"?
 - [ ] Os conteineres subiram corretamente?
 - [ ] Alterar o Git reflete no Portainer (se testado pull)?
--- a/conteineres/Nivel_1/Gestao_Stacks_Portainer.pdf
+++ b/conteineres/Nivel_1/Gestao_Stacks_Portainer.pdf
--- a/conteineres/Nivel_1/Instalacao_Docker_Compose_Linux.md
+++ b/conteineres/Nivel_1/Instalacao_Docker_Compose_Linux.md
@ -0,0 +1,122 @@
 # MANUAL TÉCNICO - INSTALAÇÃO E CONFIGURAÇÃO DO DOCKER E COMPOSE (LINUX)
 **Código:** ITGSUP 0007/26 | **Classificação:** RESTRITO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Padronizar a instalação do Docker Engine e Docker Compose em servidores Linux (Ubuntu/Debian), garantindo suporte oficial e atualizações seguras.
 ## 3. PRÉ-REQUISITOS
 > Liste o que é necessário ANTES de começar.
 *   [ ] Acesso ao servidor via SSH.
 *   [ ] Usuário com privilégios de `sudo` ou `root`.
 *   [ ] Conexão com a internet liberada (Portas 80/443).
 *   [ ] Sistema Operacional compatível (Ubuntu 20.04+, Debian 11+).
 ## 4. PASSO A PASSO (EXECUÇÃO)
 **Etapa 1: Preparação do Ambiente e Repositórios**
 1.  Atualize o índice de pacotes e instale as dependências essenciais para HTTPS.
 ```bash
 sudo apt-get update
 sudo apt-get install ca-certificates curl gnupg
 ```
 2.  Adicione a chave GPG oficial do Docker para garantir a autenticidade dos pacotes.
 ```bash
 sudo install -m 0755 -d /etc/apt/keyrings
 curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
 sudo chmod a+r /etc/apt/keyrings/docker.gpg
 ```
 3.  Configure o repositório estável.
    > ℹ️ **NOTA:** O comando abaixo detecta automaticamente a versão do OS (`lsb_release`).
 ```bash
 echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 ```
 **Etapa 2: Instalação dos Pacotes**
 1.  Atualize novamente o índice (agora com o repo do Docker) e instale o Engine, CLI e plugins.
 ```bash
 sudo apt-get update
 sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
 ```
 **Etapa 3: Pós-Instalação (Permissões)**
 > ⚠️ **IMPORTANTE:** Execute isso para **não** precisar usar `sudo` em todo comando docker.
 1.  Adicione seu usuário atual ao grupo `docker`.
 2.  Aplique a mudança de grupo na sessão atual.
 ```bash
 sudo usermod -aG docker $USER
 newgrp docker
 ```
 **Etapa 4: Validação (Hello World)**
 1.  Execute o container de teste para validar a instalação completa.
 ```bash
 docker run hello-world
 ```
 2.  O resultado esperado deve ser idêntico ao bloco abaixo:
 > [!NOTE]
 > Sucesso na execução do Docker.
 ```text
 Hello from Docker!
 This message shows that your installation appears to be working correctly.
 To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 3. The Docker daemon created a new container from that image which runs the executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it to your terminal.
 ```
 ## 5. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: "permission denied while trying to connect to the Docker daemon socket"**
 *   **Causa:** O usuário não está no grupo `docker` ou a sessão não foi atualizada.
 *   **Solução:**
    1.  Execute `sudo usermod -aG docker $USER`.
    2.  Faça **logoff** e login novamente ou use `newgrp docker`.
 **Problema 2: Erro de GPG ou Repositório não encontrado**
 *   **Causa:** Chave expirada ou OS não suportado.
 *   **Solução:**
    1.  Verifique se o codename do OS em `/etc/os-release` é compatível (focal, jammy, bullseye, bookworm).
    2.  Remova o arquivo `/etc/apt/sources.list.d/docker.list` e refaça a **Etapa 1**.
 ## 6. DADOS TÉCNICOS
 | Campo | Valor | Descrição |
 | :--- | :--- | :--- |
 | **Serviço** | `docker.service` | Nome do serviço no Systemd |
 | **Config** | `/etc/docker/daemon.json` | Arquivo principal de configuração |
 | **Dados** | `/var/lib/docker` | Local padrão de imagens e volumes |
 | **Socket** | `/var/run/docker.sock` | Socket de comunicação da API |
 ## 7. VALIDAÇÃO FINAL (Definição de Pronto)
 - [ ] O comando `docker run hello-world` funciona sem sudo?
 - [ ] O comando `docker compose version` retorna a versão (ex: v2.x.x)?
 - [ ] O serviço está ativo? (`sudo systemctl status docker` mostra **active (running)**)
--- a/conteineres/Nivel_1/Instalacao_Docker_Compose_Linux.pdf
+++ b/conteineres/Nivel_1/Instalacao_Docker_Compose_Linux.pdf
--- a/conteineres/Nivel_2/Healthchecks_Cron_Docker.md
+++ b/conteineres/Nivel_2/Healthchecks_Cron_Docker.md
@ -0,0 +1,97 @@
 # MANUAL TÉCNICO - HEALTHCHECKS E SCRIPTS AUTOMATIZADOS NO DOCKER
 **Código:** ITGINF 0011/26 | **Classificação:** RESTRITO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Implementar verificações de saúde (Healthchecks) para auto-cura de aplicações e configurar tarefas agendadas (Cron) de forma compatível com conteineres.
 ## 3. PRÉ-REQUISITOS
 - [ ] Conhecimento de Dockerfile e Docker Compose.
 ## 4. PASSO A PASSO (EXECUÇÃO)
 **Etapa 1: Definindo HEALTHCHECK no Dockerfile**
 > ℹ️ **NOTA:** O Docker executa esse comando periodicamente. Se falhar X vezes, marca o container como `unhealthy`.
 1.  Edite seu `Dockerfile`.
 2.  Adicione a instrução (exemplo para web server):
 ```dockerfile
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost/ || exit 1
 ```
 **Etapa 2: Definindo HEALTHCHECK no Compose**
 1.  No `docker-compose.yml`, você pode sobrescrever ou definir:
 ```yaml
 version: '3.8'
 services:
  web:
    image: nginx
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 1m30s
      timeout: 10s
      retries: 3
 ```
 **Etapa 3: Scripts Agendados (Cron)**
 > ⚠️ **IMPORTANTE:** Conteineres devem ter UM processo principal. Rodar `cron` junto com `apache` no mesmo container é má prática ("Fat Container").
 **Abordagem A: Container Dedicado (Sidecar)**
 1.  Crie um container pequeno (Alpine) só para rodar o script e sair.
 2.  Agende a execução desse container pelo `cron` do **HOST**.
    ```bash
    # No crontab do HOST (crontab -e)
    # Roda backup do banco postgres todo dia as 03:00
    0 3 * * * docker exec meu-postgres pg_dumpall > /backups/db.sql
    ```
 **Abordagem B: Ofelia (Job Scheduler for Docker)**
 1.  Use uma imagem especializada que escuta events do Docker.
    ```yaml
    services:
      ofelia:
        image: mcuadros/ofelia:latest
        depends_on:
          - web
        command: daemon --docker
        volumes:
          - /var/run/docker.sock:/var/run/docker.sock
      web:
        image: my-app
        labels:
          ofelia.enabled: "true"
          ofelia.job-exec.datecron.schedule: "@every 10s"
          ofelia.job-exec.datecron.command: "echo 'Backup process...'"
    ```
 ## 5. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: Container sempre em `starting`**
 *   **Causa:** O healthcheck nunca passa com sucesso.
 *   **Solução:**
    1.  Rode o comando do healthcheck manualmente: `docker exec -it [ID] curl ...`.
    2.  Verifique se o `curl`/`wget` está instalado na imagem.
 **Problema 2: Cron dentro do container não roda**
 *   **Causa:** Variáveis de ambiente não passam automaticamente para o cron.
 *   **Solução:** Sempre use caminhos absolutos nos scripts e carregue as variáveis se necessário.
 ## 6. VALIDAÇÃO FINAL
 - [ ] `docker ps` mostra status `(healthy)`?
 - [ ] O comando agendado foi executado no horário previsto?
--- a/conteineres/Nivel_2/Healthchecks_Cron_Docker.pdf
+++ b/conteineres/Nivel_2/Healthchecks_Cron_Docker.pdf
--- a/conteineres/Nivel_2/Redes_e_Firewall_Docker.md
+++ b/conteineres/Nivel_2/Redes_e_Firewall_Docker.md
@ -0,0 +1,94 @@
 # MANUAL TÉCNICO - REDES E FIREWALL NO DOCKER
 **Código:** ITGINF 0009/26 | **Classificação:** RESTRITO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Explicar a arquitetura de redes do Docker (Bridge, Host, Overlay), como segregar conteineres e como gerenciar regras de Firewall com segurança.
 ## 3. PRÉ-REQUISITOS
 - [ ] Docker Engine instalado e rodando.
 - [ ] Acesso root para visualizar regras de iptables.
 ## 4. PASSO A PASSO (EXECUÇÃO)
 **Etapa 1: Drivers de Rede Padrão**
 1.  Liste as redes existentes no host.
    *   **bridge:** Padrão. Conteineres recebem IP interno (172.17.x.x).
    *   **host:** Remove isolamento. Container usa a eth0 do host.
    *   **none:** Sem rede.
 ```bash
 docker network ls
 ```
 **Etapa 2: Criando Redes Segregadas (User-defined Bridge)**
 > 🚀 **MELHOR PRÁTICA:** Nunca use a rede `bridge` padrão para produção (falta DNS resolution entre nomes). Crie a sua.
 1.  Crie uma rede dedicada para sua stack (ex: `app-network`).
 2.  Suba conteineres conectados a ela.
 ```bash
 docker network create --driver bridge app-network
 docker run -d --name meu-db --network app-network postgres
 docker run -d --name meu-app --network app-network nginx
 ```
 > [!NOTE]
 > Agora o container `meu-app` consegue pingar `meu-db` pelo NOME. A rede bridge padrão não faz isso.
 **Etapa 3: Exposição de Portas e Segurança (Firewall)**
 > ⚠️ **IMPORTANTE:** O Docker insere regras no `iptables` ANTES do UFW. Liberar `-p 8080:80` ignora o bloqueio do UFW.
 1.  **Modo Inseguro (Padrão):** Libera para internet (0.0.0.0).
    ```bash
    docker run -p 8080:80 nginx
    ```
 2.  **Modo Seguro (Localhost Apenas):** Use se for usar proxy reverso (Nginx/Traefik) no host.
    ```bash
    docker run -p 127.0.0.1:8080:80 nginx
    ```
 **Etapa 4: Auditoria de Regras**
 1.  Verifique como o Docker mapeia as regras no NAT.
 ```bash
 sudo iptables -t nat -L DOCKER
 ```
 ## 5. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: Container não resolve DNS externo**
 *   **Causa:** Conflito de DNS no `/etc/docker/daemon.json` ou firewall bloqueando porta 53 UDP.
 *   **Solução:**
    1.  Teste com `docker run busybox nslookup google.com`.
    2.  Check se o host tem acesso.
 **Problema 2: UFW não bloqueia portas do Docker**
 *   **Causa:** Design do Docker ("Docker bypasses UFW").
 *   **Solução:**
    1.  Edite `/etc/default/docker` e adicione `--iptables=false` (Cuidado: quebra o NAT!).
    2.  **Recomendado:** Use o bloqueio na chain `DOCKER-USER` do iptables se precisar restringir IPs externos.
 ## 6. DADOS TÉCNICOS
 | Campo | Valor | Descrição |
 | :--- | :--- | :--- |
 | **Subnet Padrão** | `172.17.0.0/16` | Rede Bridge padrão |
 | **DNS Interno** | `127.0.0.11` | Resolver interno do Docker |
 ## 7. VALIDAÇÃO FINAL
 - [ ] `docker network ls` mostra sua rede customizada?
 - [ ] Conteineres na mesma rede se pingam por nome?
 - [ ] Portas expostas estão acessíveis (netstat -tuln)?
--- a/conteineres/Nivel_2/Redes_e_Firewall_Docker.pdf
+++ b/conteineres/Nivel_2/Redes_e_Firewall_Docker.pdf
--- a/conteineres/Nivel_2/Volumes_e_Persistencia_Docker.md
+++ b/conteineres/Nivel_2/Volumes_e_Persistencia_Docker.md
@ -0,0 +1,90 @@
 # MANUAL TÉCNICO - VOLUMES E PERSISTÊNCIA DE DADOS NO DOCKER
 **Código:** ITGINF 0010/26 | **Classificação:** RESTRITO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Definir estratégias de persistência de dados em conteineres (Stateful), diferenciando Volumes gerenciados de Bind Mounts e garantindo backup e permissões corretas.
 ## 3. PRÉ-REQUISITOS
 - [ ] Docker Engine instalado.
 - [ ] Entendimento básico de permissões Linux (chmod/chown).
 ## 4. PASSO A PASSO (EXECUÇÃO)
 **Etapa 1: Volumes Gerenciados (Recomendado)**
 > ℹ️ **NOTA:** Volumes são gerenciados pelo Docker em `/var/lib/docker/volumes`. São mais fáceis de fazer backup e migrar.
 1.  Crie um volume explícito.
    ```bash
    docker volume create dados-postgres
    ```
 2.  Use o volume em um container.
    ```bash
    docker run -d --name db-prod -v dados-postgres:/var/lib/postgresql/data postgres:15
    ```
 **Etapa 2: Bind Mounts (Caminhos do Host)**
 > ⚠️ **IMPORTANTE:** Use Bind Mounts para arquivos de configuração (`nginx.conf`) ou código fonte em desenvolvimento.
 1.  Mapeie um diretório local absoluto para dentro do container.
    ```bash
    docker run -d \
      --name web-server \
      -v /home/user/meu-site:/usr/share/nginx/html:ro \
      nginx
    ```
    > `:ro` = Read Only (O container não pode alterar os arquivos do host).
 **Etapa 3: Inspecionando Volumes**
 1.  Descubra onde os dados estão realmente salvos no disco.
 ```bash
 docker volume inspect dados-postgres
 ```
 **Etapa 4: Backup de Volume**
 1.  Use um container temporário para tar/zipar o conteúdo de um volume.
 ```bash
 docker run --rm \
  -v dados-postgres:/volume \
  -v $(pwd):/backup \
  alpine tar cvf /backup/backup.tar /volume
 ```
 ## 5. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: "Permission Denied" ao escrever no volume**
 *   **Causa:** O UID do processo dentro do container é diferente do UID do dono da pasta no host (Bind Mount).
 *   **Solução:**
    1.  Descubra o UID interno: `docker exec container id`.
    2.  Ajuste o dono no host: `sudo chown -R 1000:1000 /pasta/local`.
 **Problema 2: Volume órfão (Dados "perdidos")**
 *   **Causa:** Remover container sem remover volume mantém os dados (o que é bom), mas pode confundir.
 *   **Solução:**
    1.  Liste volumes: `docker volume ls`.
    2.  Remova não usados: `docker volume prune`.
 ## 6. DADOS TÉCNICOS
 | Campo | Valor | Descrição |
 | :--- | :--- | :--- |
 | **Path Linux** | `/var/lib/docker/volumes` | Local padrão dos volumes |
 | **Driver** | `local` | Driver padrão |
 ## 7. VALIDAÇÃO FINAL
 - [ ] O comando `docker volume ls` lista o volume criado?
 - [ ] Se remover o container (`docker rm -f`), os dados persistem?
 - [ ] O container consegue ler/escrever no diretório mapeado?
--- a/conteineres/Nivel_2/Volumes_e_Persistencia_Docker.pdf
+++ b/conteineres/Nivel_2/Volumes_e_Persistencia_Docker.pdf
--- a/conteineres/Nivel_3/Docker_Swarm_Basico.md
+++ b/conteineres/Nivel_3/Docker_Swarm_Basico.md
@ -0,0 +1,94 @@
 # MANUAL TÉCNICO - DOCKER SWARM: INICIALIZAÇÃO E GERENCIAMENTO
 **Código:** ITGENG 0014/26 | **Classificação:** RESTRITO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Habilitar o o modo Swarm (Orquestração Nativa) para garantir alta disponibilidade, balanceamento de carga e escalabilidade horizontal de containers.
 ## 3. PRÉ-REQUISITOS
 - [ ] Mínimo de 3 máquinas com Docker instalado (Recomendado para HA).
 - [ ] Portas liberadas entre os nós: 
    *   **TCP/2377** (Cluster Management)
    *   **TCP/UDP 7946** (Communication)
    *   **UDP 4789** (Overlay Network)
 ## 4. PASSO A PASSO (EXECUÇÃO)
 **Etapa 1: Inicializando o Manager (Nó Principal)**
 1.  No servidor escolhido como líder, execute:
 ```bash
 docker swarm init --advertise-addr {{IP_DO_MANAGER}}
 ```
 2.  O comando retornará um token. Copie-o. Exemplo:
    `docker swarm join --token SWMTKN-1-xx... {{IP_DO_MANAGER}}:2377`
 **Etapa 2: Adicionando Workers**
 1.  Nos outros servidores, cole o comando copiado na etapa anterior.
 2.  Confirme a entrada no cluster:
    ```bash
    docker node ls
    ```
    > O status deve ser **Ready** e **Active**.
 **Etapa 3: Deploy de Serviços (Services vs Containers)**
 > ℹ️ **NOTA:** No Swarm, não damos deploy em "Containers", mas sim em "Services". O Swarm decide onde o container vai rodar.
 1.  Crie um serviço replicado (3 réplicas do Nginx).
 ```bash
 docker service create --name meu-site-ha --replicas 3 -p 80:80 nginx
 ```
 2.  Liste os serviços e verifique a distribuição.
 ```bash
 docker service ls
 docker service ps meu-site-ha
 ```
 **Etapa 4: Escala e Atualização (Rolling Update)**
 1.  Aumente a capacidade para 5 containers.
    ```bash
    docker service scale meu-site-ha=5
    ```
 2.  Atualize a imagem sem downtime (Rolling Update).
    ```bash
    docker service update --image nginx:alpine meu-site-ha
    ```
 ## 5. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: Nós não conseguem se comunicar (Status Down)**
 *   **Causa:** Firewall bloqueando porta 7946 ou 4789.
 *   **Solução:** Verifique `telnet IP 2377` e libere as portas no Security Group/Firewall.
 **Problema 2: Split Brain (Líderes perdidos)**
 *   **Causa:** Mais de 50% dos Managers caíram.
 *   **Solução:**
    1.  No manager sobrevivente: `docker swarm init --force-new-cluster`.
 ## 6. DADOS TÉCNICOS
 | Campo | Valor | Descrição |
 | :--- | :--- | :--- |
 | **Driver Rede** | `overlay` | Rede criptografada multi-host |
 | **Routing Mesh** | `Ingress` | Balanceador de carga interno (L4) |
 ## 7. VALIDAÇÃO FINAL
 - [ ] `docker node ls` mostra todos os nós online?
 - [ ] Ao desligar um nó worker, os containers migram para outro?
 - [ ] Acessar o IP de QUALQUER nó na porta 80 carrega o site (Routing Mesh)?
--- a/conteineres/Nivel_3/Docker_Swarm_Basico.pdf
+++ b/conteineres/Nivel_3/Docker_Swarm_Basico.pdf
--- a/conteineres/Nivel_3/Introducao_Kubernetes.md
+++ b/conteineres/Nivel_3/Introducao_Kubernetes.md
@ -0,0 +1,108 @@
 # MANUAL TÉCNICO - KUBERNETES: VISÃO GERAL E FERRAMENTAS BÁSICAS
 **Código:** ITGENG 0015/26 | **Classificação:** RESTRITO
 **Responsável:** João Pedro Toledo Gonçalves | **Data:** {{DATA_ATUAL}}
 ## 1. HISTÓRICO DE REVISÃO
 > ⚠️ **REGRA DE OURO:**
 > 1. **Autor:** João Pedro Toledo Gonçalves.
 > 2. **Descrição:** Criação do documento.
 | Data | Versão | Descrição | Autor |
 | :--- | :--- | :--- | :--- |
 | {{DATA_ATUAL}} | 1.0 | Criação Inicial | João Pedro Toledo Gonçalves |
 ## 2. OBJETIVO
 Introduzir os conceitos fundamentais do Kubernetes (K8s) e o uso da ferramenta de linha de comando `kubectl` para administração de clusters.
 ## 3. PRÉ-REQUISITOS
 - [ ] Um cluster Kubernetes ativo (Pode ser Minikube, K3s, EKS, AKS).
 - [ ] Ferramenta `kubectl` instalada localmente.
 - [ ] Arquivo de configuração `~/.kube/config` (kubeconfig).
 ## 4. CONCEITOS CHAVE
 > ℹ️ **NOTA:** O K8s é declarativo. Você define o estado desejado (YAML) e ele trabalha para manter esse estado.
 | Componente | Função | Equivalente Docker |
 | :--- | :--- | :--- |
 | **Pod** | Menor unidade deployável. Pode ter 1+ containers. | Container "Grupo" |
 | **Deployment** | Gerencia réplicas e updates de Pods. | Service (Swarm) |
 | **Service** | Expõe o Deployment na rede (ClusterIP, NodePort). | Port Mapping |
 | **Namespace** | Segregação virtual de recursos. | ~Stack Name |
 ## 5. PASSO A PASSO (EXECUÇÃO)
 **Etapa 1: Verificação de Conexão**
 1.  Verifique se o `kubectl` consegue falar com o cluster.
 ```bash
 kubectl cluster-info
 kubectl get nodes
 ```
 **Etapa 2: Deploy Imperativo (Rápido)**
 1.  Crie um deployment simples do Nginx.
 ```bash
 kubectl create deployment demo-nginx --image=nginx
 ```
 **Etapa 3: Deploy Declarativo (YAML - Recomendado)**
 1.  Crie um arquivo `app.yaml`:
 ```yaml
 apiVersion: apps/v1
 kind: Deployment
 metadata:
  name: meu-app
 spec:
  replicas: 2
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: nginx
        image: nginx:latest
 ```
 2.  Aplique o arquivo:
    ```bash
    kubectl apply -f app.yaml
    ```
 **Etapa 4: Debug e Logs**
 1.  Liste os pods para pegar o nome.
    ```bash
    kubectl get pods
    ```
 2.  Veja os logs de um pod específico.
    ```bash
    kubectl logs -f meu-app-xxxxx-xxxxx
    ```
 3.  Acesse o shell interativo.
    ```bash
    kubectl exec -it meu-app-xxxxx-xxxxx -- /bin/bash
    ```
 ## 6. SOLUÇÃO DE PROBLEMAS (TROUBLESHOOTING)
 **Problema 1: `ErrImagePull` ou `ImagePullBackOff`**
 *   **Causa:** Nome da imagem errado, tag inexistente ou falta de credenciais (Private Registry).
 *   **Solução:**
    1.  `kubectl describe pod [NOME_POD]` -> Veja a seção "Events".
 **Problema 2: `CrashLoopBackOff`**
 *   **Causa:** O container iniciou e "morreu" imediatamente (Erro na aplicação).
 *   **Solução:**
    1.  `kubectl logs [NOME_POD] --previous` para ver o log antes do crash.
 ## 7. VALIDAÇÃO FINAL
 - [ ] `kubectl get nodes` retorna status **Ready**?
 - [ ] `kubectl get pods` mostra todos os pods como **Running**?
 - [ ] É possível aplicar mudanças editando o YAML e rodando `apply` novamente?
--- a/conteineres/Nivel_3/Introducao_Kubernetes.pdf
+++ b/conteineres/Nivel_3/Introducao_Kubernetes.pdf