Laboratório 13
Checklist — automação de processos com n8n: eventos, aprovações e agentes
- n8n do grupo na rede do LAB IoT, credenciais importadas, notificação pelo ntfy e workflows exportados para o Git (T1)
- Node-RED publica eventos de alarme; o n8n abre a ocorrência, avisa e escala se ninguém reconhecer (T2)
- Relatório do turno agendado: API do Node-RED, ocorrências do n8n, arquivo no repositório e aviso (T3)
- Mudança de setpoint por formulário, com aprovação humana, comando MQTT e conferência do resultado (T4)
- n8n como servidor MCP: o agente consulta a câmara e só pede mudanças, testado sem IA e com o agente (T5)
- Workflow de erros, lint dos workflows no CI e ensaio de recuperação a partir do Git (T6)
- Previsões P1–P4 respondidas no
README.md - Nenhum token no repositório nem no chat; nenhum
push --force; cada tarefa num commitTn: - Logout do Git, do
ghe da conta do n8n no computador do laboratório
T1…T6 = 100 pts (esta aula não tem desafios): T1 10 · T2 20 · T3 15 · T4 20 · T5 15 ·
T6 20. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
Precisa do Docker Desktop aberto e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.
docker desktop start
Atenção: desligue tudo o que estiver rodando no Docker (outros LABs, outros projetos), para não haver conflito de portas nem falta de memória:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Disciplina: ELT85B - IoT Industrial.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-a"
2. Gere o LAB IoT do grupo em docker\lab13-a:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo a --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-a-nodered && (del /q "data\lab13-a\flows.json" "data\lab13-a\flows_cred.json" "data\lab13-a\.flows*.backup" 2>nul & docker compose start lab13-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-b"
2. Gere o LAB IoT do grupo em docker\lab13-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo b --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-b-nodered && (del /q "data\lab13-b\flows.json" "data\lab13-b\flows_cred.json" "data\lab13-b\.flows*.backup" 2>nul & docker compose start lab13-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-c"
2. Gere o LAB IoT do grupo em docker\lab13-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo c --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-c-nodered && (del /q "data\lab13-c\flows.json" "data\lab13-c\flows_cred.json" "data\lab13-c\.flows*.backup" 2>nul & docker compose start lab13-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-d"
2. Gere o LAB IoT do grupo em docker\lab13-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo d --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-d-nodered && (del /q "data\lab13-d\flows.json" "data\lab13-d\flows_cred.json" "data\lab13-d\.flows*.backup" 2>nul & docker compose start lab13-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-e"
2. Gere o LAB IoT do grupo em docker\lab13-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo e --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-e-nodered && (del /q "data\lab13-e\flows.json" "data\lab13-e\flows_cred.json" "data\lab13-e\.flows*.backup" 2>nul & docker compose start lab13-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-f"
2. Gere o LAB IoT do grupo em docker\lab13-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo f --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-f-nodered && (del /q "data\lab13-f\flows.json" "data\lab13-f\flows_cred.json" "data\lab13-f\.flows*.backup" 2>nul & docker compose start lab13-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-g"
2. Gere o LAB IoT do grupo em docker\lab13-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo g --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-g-nodered && (del /q "data\lab13-g\flows.json" "data\lab13-g\flows_cred.json" "data\lab13-g\.flows*.backup" 2>nul & docker compose start lab13-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-h"
2. Gere o LAB IoT do grupo em docker\lab13-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo h --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-h-nodered && (del /q "data\lab13-h\flows.json" "data\lab13-h\flows_cred.json" "data\lab13-h\.flows*.backup" 2>nul & docker compose start lab13-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-i"
2. Gere o LAB IoT do grupo em docker\lab13-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo i --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-i-nodered && (del /q "data\lab13-i\flows.json" "data\lab13-i\flows_cred.json" "data\lab13-i\.flows*.backup" 2>nul & docker compose start lab13-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-j"
2. Gere o LAB IoT do grupo em docker\lab13-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo j --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-j-nodered && (del /q "data\lab13-j\flows.json" "data\lab13-j\flows_cred.json" "data\lab13-j\.flows*.backup" 2>nul & docker compose start lab13-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-k"
2. Gere o LAB IoT do grupo em docker\lab13-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo k --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-k-nodered && (del /q "data\lab13-k\flows.json" "data\lab13-k\flows_cred.json" "data\lab13-k\.flows*.backup" 2>nul & docker compose start lab13-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-l"
2. Gere o LAB IoT do grupo em docker\lab13-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo l --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-l-nodered && (del /q "data\lab13-l\flows.json" "data\lab13-l\flows_cred.json" "data\lab13-l\.flows*.backup" 2>nul & docker compose start lab13-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-m"
2. Gere o LAB IoT do grupo em docker\lab13-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo m --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-m-nodered && (del /q "data\lab13-m\flows.json" "data\lab13-m\flows_cred.json" "data\lab13-m\.flows*.backup" 2>nul & docker compose start lab13-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab13-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab13-x"
2. Gere o LAB IoT do grupo em docker\lab13-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab13 --grupo x --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab13-x-nodered && (del /q "data\lab13-x\flows.json" "data\lab13-x\flows_cred.json" "data\lab13-x\.flows*.backup" 2>nul & docker compose start lab13-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
O Node-RED dos Labs 05 a 10 é ótimo com fluxos de dados: uma leitura a cada 2 s, uma escala, um gráfico. Uma fábrica também tem processos: um alarme que alguém precisa reconhecer, uma mudança de setpoint que um supervisor precisa aprovar, um relatório que sai a cada troca de turno. Processos esperam por pessoas, duram minutos ou horas e precisam deixar registro.
O n8n é uma plataforma de automação de processos (workflow automation): cada processo é um workflow de nós, disparado por um gatilho (uma mensagem MQTT, um horário, um formulário, uma chamada MCP). O n8n guarda cada execução, sabe esperar por uma pessoa sem travar nada e fala com centenas de serviços.
Nesta aula, cada ferramenta fica com o que faz melhor:
| No Node-RED (borda) | No n8n (processo) |
|---|---|
| recebe toda a telemetria e grava no SQLite | recebe só eventos (o alarme mudou) |
http in responde /api/estado e /api/turno | consulta essas APIs quando um processo precisa |
| fluxo sempre rodando, sem histórico de execuções | cada execução registrada: quem, quando, com que dados |
| — | espera uma pessoa (reconhecer, aprovar) por minutos ou dias |
Objetivos
- Subir e operar o n8n na rede do LAB IoT, com credenciais fora do repositório.
- Separar dados (Node-RED) de eventos e processos (n8n), e medir por quê.
- Montar processos com espera por pessoas: reconhecimento com escalonamento e aprovação.
- Integrar por API: HTTP ao Node-RED, MQTT para a câmara, ntfy para o celular.
- Expor processos a um agente de IA por MCP sem dar a ele o poder de escrever na planta.
- Tratar workflows como código: exportação, lint no CI, workflow de erros e recuperação.
Material
- O LAB IoT do
lab13-x(gerado pelogen_iot_aluno.py, pode ser com--sem-fuxa): mosquitto e Node-RED comnode-red-node-sqlite. - O repositório do grupo, que nasce do
lab13-template:camara-sim/, o fluxo do Node-RED, odocker-compose.ymldo n8n, dois workflows prontos e os scripts de teste. - ntfy: o app no celular ou o navegador, com o servidor e o token do grupo (linha do ntfy no
credenciais.txtdo LAB IoT) ou ontfy.shpúblico, com um tópico difícil de adivinhar. - Python 3 com o pacote
mcp(T5) e o VS Code com o Copilot do Lab 12 (T5).
O n8n roda num contêiner do grupo, na versão stable mais recente. O código é aberto sob a Sustainable Use License: usar uma instância própria para aprender e para processos internos é permitido; oferecer o n8n como serviço para terceiros, não. A aula não usa a nuvem do n8n, os nós de IA com chave de API nem os recursos pagos (variáveis, ambientes, Git integrado).
Clonar o repositório do grupo
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
- Grupo: Grupo-A (slug:
grupo-a) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-a/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-a.git && cd lab13-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-b/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-b.git && cd lab13-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-c/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-c.git && cd lab13-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-d/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-d.git && cd lab13-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-e/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-e.git && cd lab13-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-f/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-f.git && cd lab13-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-g/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-g.git && cd lab13-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-h/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-h.git && cd lab13-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-i/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-i.git && cd lab13-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-j/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-j.git && cd lab13-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-k/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-k.git && cd lab13-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-l/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-l.git && cd lab13-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-m/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-m.git && cd lab13-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-x/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-x.git && cd lab13-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-p/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-p.git && cd lab13-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab13-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab13-grupo-n/commits/main/
- Acessos: ACESSO-LAB13.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT85B-N21-2026-2/lab13-grupo-n.git && cd lab13-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab13-grupo-n" && code . --profile "ESP32IO"
Envie o link do repositório do seu grupo no Moodle:
lab13 ainda não tem cmid configurado em src/data/labassigns.json.Mapa de tarefas — 6 tarefas · 100 pts
- T1 — n8n no LAB IoT e a primeira automação · 10 pts
- T2 — Eventos, alarmes e escalonamento · 20 pts
- T3 — Relatório do turno · 15 pts
- T4 — Mudança de setpoint com aprovação · 20 pts
- T5 — O n8n como servidor MCP · 15 pts
- T6 — Workflows como código · 20 pts
Estrutura de Arquivos do Projeto
- ├── 📂camara-sim
- ├── 📄.env.example👈 Verificar
- └── 📄.env👈 Criar Aqui
- ├── 📂nodered
- └── 🔧flows-lab13.json👈 Edite Aqui
- ├── 📂n8n
- ├── 🚀docker-compose.yml👈 Verificar
- ├── 📄.env.example👈 Verificar
- ├── 🔧credenciais.exemplo.json👈 Verificar
- └── 📂workflows
- ├── 🔧l13-w0-notificar-ntfy.json👈 Edite Aqui
- ├── 🔧l13-w0-preparar-tabelas.json👈 Verificar
- ├── 🔧l13-w1-camara-online-offline.json👈 Criar Aqui
- ├── 🔧l13-w2-alarmes-da-camara.json👈 Criar Aqui
- ├── 🔧l13-w3-relatorio-do-turno.json👈 Criar Aqui
- ├── 🔧l13-w4-processar-pedido-de-setpoint.json👈 Criar Aqui
- ├── 🔧l13-w4-formulario-de-pedido.json👈 Criar Aqui
- ├── 🔧l13-w5-servidor-mcp-da-camara.json👈 Criar Aqui
- └── 🔧l13-w6-erros-dos-workflows.json👈 Criar Aqui
- ├── 📂relatorios
- └── 📝2026-11-10_1400.md👈 Criar Aqui
- ├── 📂ci
- ├── 📄normalizar_workflows.py👈 Verificar
- ├── 📄verificar_workflows.py👈 Edite Aqui
- └── 📄testar_mcp_n8n.py👈 Verificar
- ├── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Edite Aqui
- └── 📂workflows
- ├── 📂.vscode
- └── 🔧mcp.json👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t1-ntfy.png👈 Criar Aqui
- ├── 📄t2-ocorrencias.csv👈 Criar Aqui
- ├── 📄t2-escalado.png👈 Criar Aqui
- ├── 📄t3-ntfy.png👈 Criar Aqui
- ├── 📄t4-pedidos.csv👈 Criar Aqui
- ├── 📄t4-decisao.png👈 Criar Aqui
- ├── 📄t5-testes.txt👈 Criar Aqui
- ├── 📝t5-agente.md👈 Criar Aqui
- ├── 📄t6-erro.png👈 Criar Aqui
- ├── 📄t6-lint.txt👈 Criar Aqui
- └── 📝t6-recuperacao.md👈 Criar Aqui
- ├── 📝IA-LOG.md👈 Edite Aqui
- └── 📝README.md👈 Edite Aqui
Troque o x pela letra do seu grupo em todos os nomes abaixo.
| O quê | Valor |
|---|---|
| Tópico base da câmara (MQTT) | elt85b/lab13/grupo-x/camara |
| Eventos (T2) | elt85b/lab13/grupo-x/camara/eventos |
| Editor do n8n | http://localhost:5678 (contêiner lab13-x-n8n) |
| Node-RED (navegador) | http://localhost/lab13-x/ |
| API do Node-RED (de dentro do n8n) | http://lab13-x-nodered:1880/lab13-x/api/estado e /api/turno |
| Broker (de dentro do n8n) | mosquitto:1883 |
| Formulário de pedido (T4) | http://localhost:5678/form/lab13-x-pedido |
| Servidor MCP (T5) | http://localhost:5678/mcp/lab13-x-camara |
Os workflows vivem dentro do n8n (volume n8n_data). O que vai para o repositório é a
exportação, feita com o comando da seção 1.5 ao fim de cada tarefa.
Parte 1 — n8n no LAB IoT e a primeira automação
1.1 A câmara e o Node-RED
- LAB IoT: suba o do
lab13-xe confira o Node-RED emhttp://localhost/lab13-x/. - Câmara: na pasta
camara-sim/,copy .env.example .env, troque oxe suba comdocker compose -f docker-compose.yml -f docker-compose.lab.yml up -d --build. - Node-RED: Menu ☰ → Import →
nodered/flows-lab13.json→ Import → Deploy. A aba Lab 13 - borda grava a telemetria no SQLite e responde a duas APIs. Confira no navegador:
| Endereço | Resposta esperada |
|---|---|
http://localhost/lab13-x/api/estado | a última telemetria, com status e idade_s |
http://localhost/lab13-x/api/turno?horas=1 | o resumo da última hora (cresce a cada 10 s) |
1.2 O n8n
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
1. Subir o n8n:
cd n8n
copy .env.example .env
notepad .env
docker compose up -d
docker compose logs -f
No .env, troque o x em GRUPO e LAB_REDE. Espere no log a linha
Editor is now accessible via: http://localhost:5678 e saia com Ctrl+C (o n8n continua
rodando). Abra http://localhost:5678 e crie a conta de dono (owner) com o e-mail de um
integrante e uma senha forte: ela fica só no seu PC, mas protege tudo o que o n8n pode fazer.
1.3 Credenciais fora do Git
Um workflow nunca guarda senha: ele aponta para uma credencial, que o n8n guarda
criptografada no volume. Os workflows do repositório apontam para três credenciais com
ids fixos, que você cria a partir do n8n/credenciais.exemplo.json:
| Credencial | Para quê | O que preencher |
|---|---|---|
MQTT LAB IoT | MQTT Trigger e MQTT | nada: mosquitto:1883, sem login (padrão do LAB IoT) |
ntfy do grupo | publicar no ntfy | Bearer <token do ntfy do grupo> |
MCP do grupo | proteger o servidor MCP (T5) | um token longo e aleatório (py -c "import secrets;print(secrets.token_urlsafe(32))") |
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-a-n8n:/tmp/credenciais.json
docker exec -u node lab13-a-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-a-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-b-n8n:/tmp/credenciais.json
docker exec -u node lab13-b-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-b-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-c-n8n:/tmp/credenciais.json
docker exec -u node lab13-c-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-c-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-d-n8n:/tmp/credenciais.json
docker exec -u node lab13-d-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-d-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-e-n8n:/tmp/credenciais.json
docker exec -u node lab13-e-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-e-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-f-n8n:/tmp/credenciais.json
docker exec -u node lab13-f-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-f-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-g-n8n:/tmp/credenciais.json
docker exec -u node lab13-g-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-g-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-h-n8n:/tmp/credenciais.json
docker exec -u node lab13-h-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-h-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-i-n8n:/tmp/credenciais.json
docker exec -u node lab13-i-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-i-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-j-n8n:/tmp/credenciais.json
docker exec -u node lab13-j-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-j-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-k-n8n:/tmp/credenciais.json
docker exec -u node lab13-k-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-k-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-l-n8n:/tmp/credenciais.json
docker exec -u node lab13-l-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-l-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-m-n8n:/tmp/credenciais.json
docker exec -u node lab13-m-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-m-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-x-n8n:/tmp/credenciais.json
docker exec -u node lab13-x-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-x-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-p-n8n:/tmp/credenciais.json
docker exec -u node lab13-p-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-p-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
1. Importar as credenciais:
copy credenciais.exemplo.json credenciais.json
notepad credenciais.json
docker cp credenciais.json lab13-n-n8n:/tmp/credenciais.json
docker exec -u node lab13-n-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-n-n8n rm /tmp/credenciais.json
git status --short --ignored credenciais.json
O último comando tem de mostrar !! credenciais.json: o arquivo está no .gitignore e não vai
para o repositório. Guarde-o como você guarda o .env: ele é a única cópia legível dos tokens.
No ntfy.sh público sem login não há token. Nesse caso, depois de importar os workflows (1.4),
abra o nó Publica no ntfy do W0 e troque Authentication para None. O tópico vira a
única proteção: use um nome difícil de adivinhar.
1.4 Os workflows prontos e a notificação
A pasta n8n/workflows/ traz dois workflows:
| Workflow | O que faz |
|---|---|
| L13 W0 Notificar (ntfy) | sub-workflow chamado por todos os outros: recebe titulo, mensagem, prioridade, tags, link e rotulo e publica no ntfy |
| L13 W0 Preparar tabelas | cria as tabelas ocorrencias e pedidos (T2) |
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Importar os workflows do repositório:
docker exec -u node lab13-a-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-b-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-c-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-d-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-e-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-f-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-g-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-h-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-i-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-j-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-k-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-l-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-m-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-x-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-p-n8n n8n import:workflow --separate --input=/home/node/workflows
1. Importar os workflows do repositório:
docker exec -u node lab13-n-n8n n8n import:workflow --separate --input=/home/node/workflows
No editor (recarregue a página), abra o W0 Notificar. No nó Configuração, ponha a URL do
ntfy (ntfy_url, a do credenciais.txt ou https://ntfy.sh) e o tópico do grupo
(ntfy_topico). Clique em Publish: um sub-workflow só pode ser chamado depois de publicado.
O n8n roda num contêiner: para ele, localhost é o próprio contêiner. Se a URL do ntfy do
credenciais.txt começar com http://localhost, troque localhost por host.docker.internal.
1.5 A primeira automação: câmara online e offline
Crie um workflow novo chamado L13 W1 Câmara online/offline:
| Nó | Configuração |
|---|---|
| MQTT Trigger | credencial MQTT LAB IoT, Topics elt85b/lab13/grupo-x/camara/status |
| Execute Sub-workflow | From list: L13 W0 Notificar (ntfy); nos campos: titulo = Câmara {{ $json.message }}; prioridade = 4 se offline, 2 se não; tags = warning ou white_check_mark |
Para a prioridade, use uma expressão: {{ $json.message === 'offline' ? 4 : 2 }}. Salve e clique
em Publish. Teste parando e subindo a câmara:
docker stop lab13-x-camara
docker start lab13-x-camara
Cada mudança chega no ntfy. Na aba Executions do workflow, abra uma execução e veja os dados
de cada nó. Capture o ntfy com as duas notificações em evidencias/t1-ntfy.png.
P1: (a) Logo depois do Publish, chega um "Câmara online" sem a câmara ter mudado. Por
quê? O que acontece ao reiniciar o n8n (docker compose restart na pasta n8n)? (b) A
telemetria chega a cada 2 s. Quantas execuções por dia teria um workflow que assinasse
.../telemetria? (c) Pare a câmara com docker kill em vez de docker stop. Quem publica o
"offline" em cada caso? E se o cabo de rede da câmara fosse cortado?
1.6 Exportar para o Git
Este é o comando que você vai repetir ao fim de cada tarefa:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Exportar os workflows:
docker exec -u node lab13-a-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo a --so-regras
1. Exportar os workflows:
docker exec -u node lab13-b-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo b --so-regras
1. Exportar os workflows:
docker exec -u node lab13-c-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo c --so-regras
1. Exportar os workflows:
docker exec -u node lab13-d-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo d --so-regras
1. Exportar os workflows:
docker exec -u node lab13-e-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo e --so-regras
1. Exportar os workflows:
docker exec -u node lab13-f-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo f --so-regras
1. Exportar os workflows:
docker exec -u node lab13-g-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo g --so-regras
1. Exportar os workflows:
docker exec -u node lab13-h-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo h --so-regras
1. Exportar os workflows:
docker exec -u node lab13-i-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo i --so-regras
1. Exportar os workflows:
docker exec -u node lab13-j-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo j --so-regras
1. Exportar os workflows:
docker exec -u node lab13-k-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo k --so-regras
1. Exportar os workflows:
docker exec -u node lab13-l-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo l --so-regras
1. Exportar os workflows:
docker exec -u node lab13-m-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo m --so-regras
1. Exportar os workflows:
docker exec -u node lab13-x-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo x --so-regras
1. Exportar os workflows:
docker exec -u node lab13-p-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo p --so-regras
1. Exportar os workflows:
docker exec -u node lab13-n-n8n n8n export:workflow --all --separate --output=/home/node/workflows/
py ci\normalizar_workflows.py
py ci\verificar_workflows.py --grupo n --so-regras
A exportação grava um arquivo por workflow, com o dono (nome e e-mail) e datas que mudam a
cada vez. O normalizar_workflows.py tira isso, renomeia cada arquivo pelo nome do workflow e
deixa só o que a importação precisa. O verificar_workflows.py é o lint da T6: por enquanto, só
as regras gerais (nenhum segredo, tópicos do grupo).
- ├── 📂camara-sim
- └── 📄.env👈 Criar Aqui
- ├── 📂n8n
- └── 📂workflows
- ├── 🔧l13-w0-notificar-ntfy.json👈 Edite Aqui
- └── 🔧l13-w1-camara-online-offline.json👈 Criar Aqui
- └── 📂workflows
- ├── 📂evidencias
- └── 📄t1-ntfy.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir camara-sim/.env n8n/workflows/l13-w0-notificar-ntfy.json n8n/workflows/l13-w1-camara-online-offline.json evidencias/t1-ntfy.png README.md
n8n no LAB IoT e a primeira automação
git conferir camara-sim/.env n8n/workflows evidencias/t1-ntfy.png README.md
git add camara-sim/.env n8n/workflows evidencias/t1-ntfy.png README.md && git commit -m "T1: n8n no LAB IoT e a primeira automação" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.
Parte 2 — Eventos, alarmes e escalonamento
O n8n registra cada execução. Isso é ótimo para um alarme e péssimo para uma leitura a cada 2 s (P1). Quem olha a telemetria é o Node-RED; o n8n só recebe eventos: "o alarme mudou".
2.1 Eventos no Node-RED
Na aba Lab 13 - borda, onde está o comentário da T2, ligue à saída do mqtt in da
telemetria uma function e, depois dela, um mqtt out no tópico
elt85b/lab13/grupo-x/camara/eventos (QoS 1). A function publica só quando o campo alarme
muda (bit 1 = sobretemperatura, bit 2 = falha do sensor):
const t = msg.payload;
const antes = context.get("alarme");
context.set("alarme", t.alarme);
if (antes === undefined || antes === t.alarme) return null; // só mudanças
const texto = [];
// TODO: "sobretemperatura" se o bit 1 estiver ligado, "falha do sensor" se o bit 2 estiver
msg.payload = {
tipo: "alarme",
ativo: t.alarme !== 0,
de: antes,
para: t.alarme,
texto: texto.join(" + ") || "normalizado",
temp: t.temp,
sp: t.sp_efetivo,
modo: t.modo,
estado: t.estado_txt,
ts: new Date().toISOString(),
};
return msg;
Deploy. Para testar sem esquentar a câmara até 60 °C, simule a falha do sensor: no MQTT
Explorer, publique 1 em elt85b/lab13/grupo-x/camara/cmd/falha_dht e, depois, 0. Cada
mudança gera um evento. Exporte o fluxo (Menu ☰ → Export → aba atual) por cima de
nodered/flows-lab13.json.
2.2 As tabelas
O n8n tem tabelas de dados (Data tables) próprias. Abra o L13 W0 Preparar tabelas e
clique em Execute workflow. Na tela inicial do n8n, aba Data tables, aparecem
ocorrencias e pedidos.
2.3 O workflow de alarmes
Crie o L13 W2 Alarmes da câmara. A estrutura:
| Nó | Configuração |
|---|---|
| MQTT Trigger | Topics .../camara/eventos; Options → JSON Parse Body ligado |
| Switch | Mode Expression, Number of Outputs 3, Output Index {{ $json.message.ativo ? ($json.message.de === 0 ? 0 : 1) : 2 }} |
| Code "dados" | devolve texto, inicio (= ts), temp, estado: 'aberta' e reconhecida_por: '' |
| Data table (insert) | tabela ocorrencias (By Name), colunas mapeadas automaticamente: devolve o id da linha |
| Notificar (Execute Sub-workflow) | link = o endereço que retoma a espera, mais quem reconheceu (abaixo); rotulo = Reconhecer |
| Wait | Resume On Webhook Call, método GET, Limit Wait Time: 2 minutos |
| If | {{ !!($json.query && $json.query.por) }}: quem clicou no link traz ?por=; quem estourou o tempo, não |
O link do botão é o endereço da própria execução em espera, $execution.resumeUrl. Ele já tem
um ?signature=..., então o parâmetro novo entra com &:
{{ $execution.resumeUrl + ($execution.resumeUrl.includes('?') ? '&' : '?') + 'por=operador' }}
Depois do Wait, os dados do evento não estão mais em $json (agora é a requisição do clique).
Para usar o id da ocorrência, busque o nó pelo nome: {{ $('Abre ocorrência').first().json.id }}.
Em Settings do workflow, deixe Save successful production executions ligado e, depois da T6, escolha o workflow de erro. Publish.
2.4 Teste
Com o ntfy aberto no navegador do PC (os links usam localhost):
falha_dht= 1: chega o ALARME. Clique em Reconhecer: chega "reconhecida". Depois,falha_dht= 0: chega "normalizado", com a duração.falha_dht= 1 de novo e não reconheça. Em 2 min, chega o ESCALADO (evidencias/t2-escalado.png).falha_dht= 0.- Na aba Data tables, abra
ocorrencias, menu ⋮ → Download CSV →evidencias/t2-ocorrencias.csv.
P2: (a) Copie o link Reconhecer, apague o signature=... e abra. O que acontece? (b)
Quem consegue reconhecer um alarme do seu grupo? (c) Dispare um alarme, reinicie o n8n
(docker compose restart) antes dos 2 min e não reconheça. O alarme ainda é escalado? Onde a
espera ficou guardada?
Com N8N_URL=http://localhost:5678/, os links só abrem no PC. Para abrir no celular (mesmo
Wi-Fi), ponha o IP do PC no .env do n8n (N8N_URL=http://192.168.0.10:5678/), rode
docker compose up -d e libere a porta 5678 no firewall do Windows.
- ├── 📂nodered
- └── 🔧flows-lab13.json👈 Edite Aqui
- ├── 📂n8n
- └── 📂workflows
- └── 🔧l13-w2-alarmes-da-camara.json👈 Criar Aqui
- └── 📂workflows
- ├── 📂evidencias
- ├── 📄t2-ocorrencias.csv👈 Criar Aqui
- └── 📄t2-escalado.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir nodered/flows-lab13.json n8n/workflows/l13-w2-alarmes-da-camara.json evidencias/t2-ocorrencias.csv evidencias/t2-escalado.png README.md
Eventos, alarmes e escalonamento
git conferir nodered/flows-lab13.json n8n/workflows evidencias/t2-ocorrencias.csv evidencias/t2-escalado.png README.md
git add nodered/flows-lab13.json n8n/workflows evidencias/t2-ocorrencias.csv evidencias/t2-escalado.png README.md && git commit -m "T2: Eventos, alarmes e escalonamento" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T2.
Parte 3 — Relatório do turno
A cada troca de turno (6 h, 14 h e 22 h), o n8n junta o que o Node-RED sabe (o resumo do
SQLite) e o que só o n8n sabe (as ocorrências) num relatório em Markdown, grava o arquivo na
pasta relatorios/ do repositório e avisa o turno.
Crie o L13 W3 Relatório do turno:
| Nó | Configuração |
|---|---|
| Schedule Trigger | Custom (Cron): 0 6,14,22 * * * |
| Manual Trigger | para testar sem esperar o turno, ligado no mesmo próximo nó |
| HTTP Request | GET http://lab13-x-nodered:1880/lab13-x/api/turno?horas=8 |
| Data table (get) | ocorrencias com inicio ≥ {{ $now.minus({ hours: 8 }).toISO() }}, Return All; em Settings do nó, Always Output Data (turno sem ocorrência) |
| Code | monta o Markdown (abaixo) e o nome do arquivo |
| Convert to File | Convert to Text File, campo texto |
| Read/Write Files from Disk | Write, /home/node/.n8n-files/{{ $('Code').first().json.arquivo }} |
| Notificar | prioridade 2, tags = clipboard, com um resumo de uma linha |
O relatório tem de ter: data e hora, período e número de amostras, temperatura média, mínima e máxima, umidade média, erro médio |SP − T|, aquecedor médio, o tempo em cada estado e a lista de ocorrências com hora local, texto, estado e quem reconheceu. Um começo para o Code:
const r = $("HTTP Request").first().json; // resumo do Node-RED
const oc = $input
.all()
.map((i) => i.json)
.filter((o) => o.id);
const agora = $now.setZone("America/Sao_Paulo");
const L = [`# Relatório do turno — ${agora.toFormat("dd/LL/yyyy HH:mm")}`, ""];
L.push(`Período: últimas ${r.horas} h (${r.amostras} amostras de 10 s).`);
// ... a tabela de grandezas, o tempo em cada estado e as ocorrências
return [
{
json: {
texto: L.join("\n") + "\n",
arquivo: `relatorios/${agora.toFormat("yyyy-LL-dd_HHmm")}.md`,
resumo: `T média ${r.temp_media} °C, ${oc.length} ocorrência(s).`,
},
},
];
O docker-compose.yml do n8n liga a pasta relatorios/ do repositório a
/home/node/.n8n-files/relatorios: é a única pasta em que o n8n 2 pode gravar arquivos.
Publish, rode pelo Manual Trigger e confira o arquivo novo em relatorios/. Capture a
notificação em evidencias/t3-ntfy.png.
- ├── 📂n8n
- └── 📂workflows
- └── 🔧l13-w3-relatorio-do-turno.json👈 Criar Aqui
- └── 📂workflows
- ├── 📂relatorios
- └── 📝2026-11-10_1400.md👈 Criar Aqui
- └── 📂evidencias
- └── 📄t3-ntfy.png👈 Criar Aqui
git conferir n8n/workflows/l13-w3-relatorio-do-turno.json relatorios/2026-11-10_1400.md evidencias/t3-ntfy.png
Relatório do turno
git conferir n8n/workflows relatorios evidencias/t3-ntfy.png
git add n8n/workflows relatorios evidencias/t3-ntfy.png && git commit -m "T3: Relatório do turno" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T3.
Parte 4 — Mudança de setpoint com aprovação
No Lab 09, qualquer um com o dashboard mudava o setpoint. Agora, a mudança é um processo: o operador pede, um supervisor aprova, o n8n aplica e confere, e tudo fica registrado.
São dois workflows. O processar faz o trabalho e pode ser chamado de vários lugares (o formulário agora, o agente na T5); o formulário só recolhe o pedido.
4.1 L13 W4 Processar pedido de setpoint
| Nó | Regra |
|---|---|
| Code "valida" | setpoint de 20 a 45 °C (arredondado a 0,5); modo pi_interno ou onoff; motivo com 10 caracteres ou mais; tira caracteres de controle e corta textos longos. Se falhar, estado = recusado: <motivos>; se não, pendente |
| Notificar supervisor | link = {{ $execution.resumeFormUrl }}, rotulo = Decidir, prioridade 4 |
| Wait | Resume On Form Submitted; campos: Decisão (Radio: Aprovar, Recusar), Supervisor, Comentário; Limit Wait Time 30 min |
| Code "decisão" | sem resposta: expirado; Recusar: recusado pelo supervisor; supervisor igual ao operador: recusado: quem pede não aprova; senão aprovado |
| MQTT | tópico .../camara/cmd, mensagem {"setpoint": <sp>, "fonte_sp": 0, "modo": 2} (1 para onoff), QoS 1 |
| Code "confere" | aplicado se o sp_efetivo lido for o pedido; senão falhou: a câmara está em ... |
O fonte_sp: 0 tira o setpoint do potenciômetro: sem ele, a câmara ignora o setpoint remoto.
4.2 L13 W4 Formulário de pedido
| Nó | Configuração |
|---|---|
| n8n Form Trigger | campos Operador, Setpoint (Number), Modo (Dropdown: pi_interno, onoff), Motivo (Textarea), todos obrigatórios; Options → Form Path lab13-x-pedido e Form Response → Text to Show "Pedido registrado..." |
| Execute Sub-workflow | L13 W4 Processar pedido de setpoint, origem = formulario; Options → Wait For Sub-Workflow Completion desligado |
Publique o processar primeiro e depois o formulário (o n8n recusa publicar um workflow que chama outro ainda não publicado).
4.3 Teste
Pelo formulário (http://localhost:5678/form/lab13-x-pedido), faça três pedidos e decida cada
um pelo link Decidir do ntfy:
| Pedido | Decisão | Resultado esperado |
|---|---|---|
| 50 °C | (nenhuma: nem chega ao supervisor) | recusado: setpoint fora de 20–45 °C |
| 30 °C, operador Ana | Aprovar, supervisor Ana | recusado: quem pede não aprova |
38 °C pi_interno, operador Ana | Aprovar, supervisor Bruno | aplicado, e a câmara em 38 °C |
Capture a tela de decisão em evidencias/t4-decisao.png e exporte a tabela pedidos para
evidencias/t4-pedidos.csv. Tente abrir de novo um link Decidir já usado.
- ├── 📂n8n
- └── 📂workflows
- ├── 🔧l13-w4-processar-pedido-de-setpoint.json👈 Criar Aqui
- └── 🔧l13-w4-formulario-de-pedido.json👈 Criar Aqui
- └── 📂workflows
- └── 📂evidencias
- ├── 📄t4-pedidos.csv👈 Criar Aqui
- └── 📄t4-decisao.png👈 Criar Aqui
git conferir n8n/workflows/l13-w4-processar-pedido-de-setpoint.json n8n/workflows/l13-w4-formulario-de-pedido.json evidencias/t4-pedidos.csv evidencias/t4-decisao.png
Mudança de setpoint com aprovação
git conferir n8n/workflows evidencias/t4-pedidos.csv evidencias/t4-decisao.png
git add n8n/workflows evidencias/t4-pedidos.csv evidencias/t4-decisao.png && git commit -m "T4: Mudança de setpoint com aprovação" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.
Parte 5 — O n8n como servidor MCP
No Lab 12, o agente do VS Code falou com um servidor MCP em Python. O n8n também é um servidor MCP: o nó MCP Server Trigger transforma workflows em ferramentas. A diferença é o que o agente não recebe: nenhuma ferramenta escreve na câmara. Ele consulta e pede; quem decide é uma pessoa, pelo processo da T4.
5.1 As ferramentas
| Ferramenta | Nó ligado ao MCP Server Trigger | Faz |
|---|---|---|
estado_camara | Call n8n Workflow Tool → workflow L13 W5 Ferramenta: estado da câmara (When Executed by Another Workflow → HTTP /api/estado → Code com os campos úteis) | lê o estado |
pedir_setpoint | Call n8n Workflow Tool → workflow L13 W5 Ferramenta: registrar pedido | registra um pedido com origem = mcp e operador agente (MCP) |
listar_pedidos | Data table (como ferramenta), Get em pedidos, 5 linhas, ordem decrescente de createdAt | mostra o estado dos pedidos |
O registrar pedido chama o processar da T4 com Wait For Sub-Workflow Completion
desligado e responde na hora: "Pedido registrado... NÃO foi aplicado: aguarda a aprovação de
um supervisor humano". Nos campos do pedir_setpoint, deixe o modelo definir o valor (o botão ao lado de cada
campo): o n8n gera {{ $fromAI('setpoint', ...) }} e o parâmetro aparece no esquema da
ferramenta. Escreva descrições claras: são o que o agente lê.
O MCP Server Trigger: Authentication Bearer Auth com a credencial MCP do grupo,
Path lab13-x-camara. Publique na ordem: estado, registrar, servidor MCP.
5.2 Testar sem IA
py -m pip install mcp
set N8N_MCP_TOKEN=<o token da credencial MCP do grupo>
py ci\testar_mcp_n8n.py --grupo lab13-x > evidencias\t5-testes.txt 2>&1
set N8N_MCP_TOKEN=
type evidencias\t5-testes.txt
Tem de terminar com Resultado: tudo certo. O teste confere que o servidor recusa quem não tem
token, que as três ferramentas existem, que nenhuma escreve direto e que um pedido de teste
aparece em listar_pedidos. Recuse o pedido de teste no link do ntfy.
5.3 O agente
No .vscode/mcp.json do repositório (o mesmo formato do Lab 12), o servidor é HTTP:
{
"inputs": [
{
"type": "promptString",
"id": "n8n-mcp-token",
"description": "Token MCP do n8n do grupo",
"password": true
}
],
"servers": {
"camara-n8n": {
"type": "http",
"url": "http://localhost:5678/mcp/lab13-x-camara",
"headers": { "Authorization": "Bearer ${input:n8n-mcp-token}" }
}
}
}
Inicie o servidor (Start acima de "camara-n8n") e, no modo Agent, peça em dois chats:
1) Como está a câmara? Ponha-a em 50 °C com o PI.
2) Ponha a câmara em 36 °C com o PI, porque vamos trocar o lote. Depois me diga se já foi aplicado.
Em evidencias/t5-agente.md, cole os pedidos, as ferramentas que o agente chamou e as respostas.
Aprove o pedido de 36 °C pelo link do ntfy e pergunte de novo ao agente se foi aplicado.
P3: (a) Na T4, o supervisor digita o próprio nome. O que impede o operador de aprovar o próprio pedido digitando outro nome? Como resolver? (b) No pedido de 50 °C ao agente, quem recusa: o modelo, o n8n ou a câmara? E se o agente insistir com 44 °C? (c) Por que o registrar pedido não espera o processar terminar?
- ├── 📂n8n
- └── 📂workflows
- ├── 🔧l13-w5-servidor-mcp-da-camara.json👈 Criar Aqui
- ├── 🔧l13-w5-ferramenta-estado-da-camara.json👈 Criar Aqui
- └── 🔧l13-w5-ferramenta-registrar-pedido.json👈 Criar Aqui
- └── 📂workflows
- ├── 📂.vscode
- └── 🔧mcp.json👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t5-testes.txt👈 Criar Aqui
- └── 📝t5-agente.md👈 Criar Aqui
- ├── 📝README.md👈 Edite Aqui
- └── 📝IA-LOG.md👈 Edite Aqui
git conferir n8n/workflows/l13-w5-servidor-mcp-da-camara.json n8n/workflows/l13-w5-ferramenta-estado-da-camara.json n8n/workflows/l13-w5-ferramenta-registrar-pedido.json .vscode/mcp.json evidencias/t5-testes.txt evidencias/t5-agente.md README.md IA-LOG.md
O n8n como servidor MCP
git conferir n8n/workflows .vscode/mcp.json evidencias/t5-testes.txt evidencias/t5-agente.md README.md IA-LOG.md
git add n8n/workflows .vscode/mcp.json evidencias/t5-testes.txt evidencias/t5-agente.md README.md IA-LOG.md && git commit -m "T5: O n8n como servidor MCP" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T5.
Projeto integrador — Workflows como código
Um workflow que só existe dentro de um contêiner some com um docker compose down -v. Um
workflow que falha em silêncio é pior que nenhum. O integrador fecha as duas brechas.
Requisitos
-
Workflow de erros. Crie o L13 W6 Erros dos workflows: Error Trigger → Notificar com o nome do workflow, o último nó, a mensagem de erro e o link da execução (
{{ $json.workflow.name }},{{ $json.execution.lastNodeExecuted }},{{ $json.execution.error.message }},{{ $json.execution.url }}). Publique e, em Settings de cada workflow com gatilho ou chamado pelo MCP (W1 a W5), escolha-o em Error Workflow. -
Teste de falha. Pare o Node-RED do LAB IoT e rode o
testar_mcp_n8n.py: oestado_camarafalha e o W6 avisa. Capture emevidencias/t6-erro.png. Suba o Node-RED. -
A regra R6. O
ci/verificar_workflows.pyjá confere R1 a R5 e R7. Escreva a funçãoregra_wait_com_limite: todo Wait que espera uma pessoa (resume=webhookouform) precisa de tempo limite (limitWaitTime). Prove que ela funciona: desligue o limite do Wait do W2, exporte e rode o lint completo,py ci\verificar_workflows.py --grupo x(sem--so-regras: tem de acusar R6); religue, exporte e rode de novo. Guarde as duas saídas emevidencias/t6-lint.txt. -
O CI. No
.github/workflows/ci.yml, troqueGRUPO_LETRA: xpela letra do grupo e tire o--so-regras: o CI passa a conferir também a estrutura de cada tarefa. Ele tem de ficar verde. -
Ensaio de recuperação. Simule a perda do n8n e reconstrua tudo a partir do Git:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-a-n8n:/tmp/credenciais.json
docker exec -u node lab13-a-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-a-n8n rm /tmp/credenciais.json
docker exec -u node lab13-a-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-b-n8n:/tmp/credenciais.json
docker exec -u node lab13-b-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-b-n8n rm /tmp/credenciais.json
docker exec -u node lab13-b-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-c-n8n:/tmp/credenciais.json
docker exec -u node lab13-c-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-c-n8n rm /tmp/credenciais.json
docker exec -u node lab13-c-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-d-n8n:/tmp/credenciais.json
docker exec -u node lab13-d-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-d-n8n rm /tmp/credenciais.json
docker exec -u node lab13-d-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-e-n8n:/tmp/credenciais.json
docker exec -u node lab13-e-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-e-n8n rm /tmp/credenciais.json
docker exec -u node lab13-e-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-f-n8n:/tmp/credenciais.json
docker exec -u node lab13-f-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-f-n8n rm /tmp/credenciais.json
docker exec -u node lab13-f-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-g-n8n:/tmp/credenciais.json
docker exec -u node lab13-g-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-g-n8n rm /tmp/credenciais.json
docker exec -u node lab13-g-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-h-n8n:/tmp/credenciais.json
docker exec -u node lab13-h-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-h-n8n rm /tmp/credenciais.json
docker exec -u node lab13-h-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-i-n8n:/tmp/credenciais.json
docker exec -u node lab13-i-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-i-n8n rm /tmp/credenciais.json
docker exec -u node lab13-i-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-j-n8n:/tmp/credenciais.json
docker exec -u node lab13-j-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-j-n8n rm /tmp/credenciais.json
docker exec -u node lab13-j-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-k-n8n:/tmp/credenciais.json
docker exec -u node lab13-k-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-k-n8n rm /tmp/credenciais.json
docker exec -u node lab13-k-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-l-n8n:/tmp/credenciais.json
docker exec -u node lab13-l-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-l-n8n rm /tmp/credenciais.json
docker exec -u node lab13-l-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-m-n8n:/tmp/credenciais.json
docker exec -u node lab13-m-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-m-n8n rm /tmp/credenciais.json
docker exec -u node lab13-m-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-x-n8n:/tmp/credenciais.json
docker exec -u node lab13-x-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-x-n8n rm /tmp/credenciais.json
docker exec -u node lab13-x-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-p-n8n:/tmp/credenciais.json
docker exec -u node lab13-p-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-p-n8n rm /tmp/credenciais.json
docker exec -u node lab13-p-n8n n8n import:workflow --separate --input=/home/node/workflows
1. 1. Apagar e subir de novo:
docker compose down -v
docker compose up -d
docker compose logs -f
2. 3. Credenciais e workflows:
docker cp credenciais.json lab13-n-n8n:/tmp/credenciais.json
docker exec -u node lab13-n-n8n n8n import:credentials --input=/tmp/credenciais.json
docker exec -u root lab13-n-n8n rm /tmp/credenciais.json
docker exec -u node lab13-n-n8n n8n import:workflow --separate --input=/home/node/workflows
O -v apaga o volume: conta, credenciais, workflows, execuções e tabelas. A ordem:
- apagar e subir (espere o
Editor is now accessibleno log e saia com Ctrl+C); - criar a conta de dono no navegador;
- importar as credenciais e os workflows;
- recarregar o editor, rodar o W0 Preparar tabelas e publicar na ordem W0 Notificar, W6, W5 estado, W4 processar, W5 registrar, W4 formulário, W5 MCP, W1, W2, W3;
- testar um alarme e o
testar_mcp_n8n.py.
Cronometre do passo 1 ao 5. Em evidencias/t6-recuperacao.md, anote quanto
tempo levou, o que voltou, o que se perdeu e o que você mudaria.
P4: (a) Antes do ensaio: o que volta do Git e o que se perde para sempre? (b) Os
workflows apontam para credenciais pelo id. O que aconteceria se você recriasse as
credenciais pela tela, com os mesmos nomes? (c) O credenciais.json não vai para o Git.
Onde ele deveria ficar guardado, e quem deveria ter acesso?
- ├── 📂n8n
- └── 📂workflows
- └── 🔧l13-w6-erros-dos-workflows.json👈 Criar Aqui
- └── 📂workflows
- ├── 📂ci
- └── 📄verificar_workflows.py👈 Edite Aqui
- ├── 📂.github
- └── 📂workflows
- └── 🚀ci.yml👈 Edite Aqui
- └── 📂workflows
- ├── 📂evidencias
- ├── 📄t6-erro.png👈 Criar Aqui
- ├── 📄t6-lint.txt👈 Criar Aqui
- └── 📝t6-recuperacao.md👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir n8n/workflows/l13-w6-erros-dos-workflows.json ci/verificar_workflows.py .github/workflows/ci.yml evidencias/t6-erro.png evidencias/t6-lint.txt evidencias/t6-recuperacao.md README.md
Workflows como código
git conferir n8n/workflows ci/verificar_workflows.py .github/workflows/ci.yml evidencias/t6-erro.png evidencias/t6-lint.txt evidencias/t6-recuperacao.md README.md
git add n8n/workflows ci/verificar_workflows.py .github/workflows/ci.yml evidencias/t6-erro.png evidencias/t6-lint.txt evidencias/t6-recuperacao.md README.md && git commit -m "T6: Workflows como código" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T6.
Referência rápida
| No n8n | É |
|---|---|
| workflow | um processo: um gatilho e os nós que ele dispara |
| execução | uma rodada do workflow, guardada com os dados de cada nó (aba Executions) |
| Publish | põe a versão salva em produção; sem publicar, os gatilhos não escutam |
| sub-workflow | workflow com When Executed by Another Workflow, chamado por Execute Sub-workflow |
| credencial | segredo guardado criptografado no n8n; o workflow só aponta para ela (pelo id) |
$json | os dados do item atual; $('Nome do nó').first().json busca a saída de outro nó |
| Wait | pausa a execução (tempo, webhook ou formulário); a execução fica no banco e sobrevive a um reinício |
| Data table | tabela simples dentro do n8n; não vai na exportação dos workflows |
| Para… | Faça |
|---|---|
| ver o log do n8n | docker compose logs -f na pasta n8n |
| exportar para o Git | o comando da seção 1.6 |
| importar do Git | docker exec -u node lab13-x-n8n n8n import:workflow --separate --input=/home/node/workflows |
| esqueci a senha do dono | docker exec -u node lab13-x-n8n n8n user-management:reset e recrie a conta |
| testar uma expressão | abra o nó, clique no campo e veja o resultado embaixo; Execute step roda só aquele nó |
| Problema | O que fazer |
|---|---|
Cannot publish workflow: ... references workflow ... which is not published | publique antes o sub-workflow que ele chama |
Credential "..." no longer exists | a credencial com aquele id não existe: importe o credenciais.json (seção 1.3) |
Invalid input for 'prioridade' | o campo é número: use uma expressão {{ 4 }}, e não o texto 4 |
HTTP Request: The service refused the connection | o Node-RED não está na rede ou o nome está errado: docker network inspect lab13-x_labnet |
HTTP Request: 404 no /api/... | confira no navegador http://localhost/lab13-x/api/estado; o fluxo do Lab 13 tem de estar com Deploy |
| O MQTT Trigger não dispara | o workflow está publicado? o tópico tem o x trocado? a credencial aponta para mosquitto? |
The file or directory does not exist (T3) | o caminho tem de começar com /home/node/.n8n-files/relatorios/ |
Link do ntfy abre Invalid token | o link foi alterado ou cortado: abra o link inteiro, com o signature |
| Link do ntfy não abre no celular | N8N_URL com o IP do PC (seção 2.4) e a porta 5678 liberada |
Logout do seu ambiente dev, git e gh
Para o git "esquecer" suas informações salvas:
git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
No n8n, saia da conta (avatar, no canto inferior esquerdo → Sign out). Num computador
compartilhado, apague o n8n\credenciais.json depois do ensaio da T6 e guarde a cópia num lugar
seguro do grupo. Se o token do ntfy ou o token MCP vazaram, troque-os.
Antes de sair, faça logout para não deixar sua conta do GitHub ativa nesta máquina. Rode os comandos abaixo no Prompt de Comando (cmd), não no PowerShell.
1. Apague a credencial do GitHub salva pelo git, encerre a sessão do gh e remova seu nome e e-mail da configuração global:
(echo protocol=https&echo host=github.com) | git credential reject
gh auth logout --hostname github.com
git config --global --unset user.name
git config --global --unset user.email
Para conferir, este comando não deve mostrar nada:
cmdkey /list | findstr /i github
2. Pare os containers do lab:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
3. No navegador, saia da sua conta em github.com e feche todas as janelas.