Temari N8N - Unitat 3
Conceptes Fonamentals
Unitat 3: Conceptes Fonamentals
3.1. Nodes
Els nodes són els blocs de construcció fonamentals de N8N. Cada node és una unitat independent que realitza una acció específica.
Tipus de nodes
1. TRIGGER NODES - Inicien el workflow
Els trigger nodes són l'inici de qualsevol workflow. Defineixen QUAN s'executa el workflow.
Manual Trigger
Característiques:
- Execució manual (click a "Execute Workflow")
- Útil per a desenvolupament i testing
- No requereix configuració
Cas d'ús:
- Testing de workflows
- Execucions puntuals
- Desenvolupament
Schedule Trigger (Cron)
Configuració:
- Mode: Every X (simple)
- Mode: Cron Expression (avançat)
- Timezone: Especificar zona horària
Exemples:
"Cada hora": 0 * * * *
"Cada dia a les 9AM": 0 9 * * *
"Cada dilluns 8AM": 0 8 * * 1
"Cada 15 minuts": */15 * * * *
Cas d'ús:
- Reports diaris
- Sincronitzacions periòdiques
- Neteja de dades
Webhook Trigger
Configuració:
- HTTP Method: GET, POST, PUT, DELETE
- Path: /webhook/nom-unic
- Authentication: None, Basic Auth, Header Auth
- Response: Return Data, No Response, Last Node
Exemple URL:
https://n8n.company.com/webhook/sales-data
Cas d'ús:
- APIs públiques
- Integracions en temps real
- Notificacions de sistemes externs
Email Trigger (IMAP)
Configuració:
- Email: compte@gmail.com
- Folder: INBOX
- Action: Mark as read, Delete, Move
Cas d'ús:
- Processar comandes per email
- Tickets de suport
- Notificacions automatitzades
2. ACTION NODES - Realitzen accions
HTTP Request
Característiques:
- Mètode: GET, POST, PUT, PATCH, DELETE
- URL: dinàmica amb expressions
- Headers: personalitzables
- Body: JSON, Form, XML
- Authentication: múltiples tipus
Exemple:
Method: POST
URL: https://api.github.com/repos/{{$json.owner}}/{{$json.repo}}/issues
Headers:
Authorization: Bearer {{$credentials.github.token}}
Body:
{
"title": "{{$json.title}}",
"body": "{{$json.description}}"
}
Database Nodes (PostgreSQL, MySQL, MongoDB)
Operacions:
- Insert: afegir registres
- Update: modificar registres
- Delete: eliminar registres
- Execute Query: SQL personalitzat
Exemple PostgreSQL:
Operation: Execute Query
Query:
SELECT u.name, COUNT(o.id) as orders
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
WHERE u.created_at > '{{$json.since}}'
GROUP BY u.id
Send Email
Configuració:
- From: sender@company.com
- To: {{$json.email}}
- Subject: Your order #{{$json.order_id}}
- HTML: Template amb dades dinàmiques
Suporta:
- Attachments
- CC/BCC
- Templates HTML
3. LOGIC NODES - Control de flux
IF Node
Funcionalitat:
- Evalua condicions
- 2 sortides: True / False
- Múltiples condicions AND/OR
Exemple:
Condition 1: {{$json.amount}} > 1000
Condition 2: {{$json.status}} equals 'pending'
Combine: AND
→ True: Enviar alerta a gerència
→ False: Processar normalment
Switch Node
Funcionalitat:
- Múltiples branques basades en valors
- Com un switch/case de programació
Exemple:
Mode: Rules
Rules:
0: {{$json.priority}} equals 'high' → Route 0
1: {{$json.priority}} equals 'medium' → Route 1
2: {{$json.priority}} equals 'low' → Route 2
default: → Route 3
Merge Node
Modes:
1. Append: Combina tots els items
2. Keep Key Matches: Fusiona per clau
3. Remove Key Matches: Elimina coincidències
Exemple Append:
Input 1: [A, B, C]
Input 2: [D, E, F]
Output: [A, B, C, D, E, F]
Exemple Keep Key Matches:
Input 1: [{id:1, name:'Joan'}, {id:2, name:'Maria'}]
Input 2: [{id:1, age:30}, {id:2, age:25}]
Output: [{id:1, name:'Joan', age:30}, {id:2, name:'Maria', age:25}]
Loop Node
Funcionalitat:
- Itera sobre arrays
- Executa nodes per cada item
- Útil per a processament batch
Flux:
[Loop Start] → Process item → [Loop End] → Repeat
4. TRANSFORM NODES - Transformació de dades
Set Node
Funcionalitat:
- Establir nous camps
- Modificar camps existents
- Eliminar camps
Exemple:
Keep Only Set: false
Values to Set:
full_name: {{$json.first_name}} {{$json.last_name}}
age_group: {{$json.age >= 18 ? 'adult' : 'minor'}}
processed_at: {{$now}}
Function Node (JavaScript)
// Accés a items
const items = $input.all();
// Processar cada item
return items.map(item => {
const data = item.json;
// Càlculs complexos
const total = data.price * data.quantity * 1.21; // IVA
return {
json: {
...data,
total_with_tax: total,
discount: total > 100 ? 0.10 : 0
}
};
});
Code Node (JavaScript o Python)
# Python example
import json
from datetime import datetime
items = []
for item in $input.all():
data = item['json']
# Processing
processed = {
'original': data,
'timestamp': datetime.now().isoformat(),
'category': classify_product(data['name'])
}
items.append({'json': processed})
return items
Nodes core més utilitzats
Top 10 nodes essencials:
- HTTP Request - Cridar APIs (90% workflows)
- Set - Transformar dades simples (80% workflows)
- Function - Lògica complexa (70% workflows)
- IF - Condicionals (60% workflows)
- PostgreSQL/MySQL - Bases de dades (50% workflows)
- Schedule Trigger - Automatització temporal
- Webhook - Integracions en temps real
- Send Email - Notificacions
- Merge - Combinar dades
- Split In Batches - Processar lots
Configuració bàsica de nodes
Anatomia d'un node:
┌─────────────────────────────┐
│ Node Name │ ← Nom descriptiu
├─────────────────────────────┤
│ 📝 Parameters │ ← Configuració
│ - Parameter 1 │
│ - Parameter 2 │
├─────────────────────────────┤
│ 🔐 Credentials (optional) │ ← Autenticació
├─────────────────────────────┤
│ ⚙️ Options (advanced) │ ← Configuració avançada
└─────────────────────────────┘
Paràmetres comuns:
Expressions:
// Referència a dades del node actual
{{$json.field_name}}
// Referència a node específic
{{$node["Node Name"].json.field}}
// Funcions
{{$now}} // Timestamp actual
{{$today}} // Data actual
{{$json.price.toFixed(2)}} // Formatació
{{$json.name.toLowerCase()}} // Manipulació strings
{{$json.items.length}} // Propietats d'arrays
Always Output Data:
Continue On Fail:
Input i output de dades
Format de dades:
Tots els nodes treballen amb aquest format:
[
{
json: {
// Les teves dades aquí
id: 1,
name: "Joan",
email: "joan@example.com"
},
binary: {
// Fitxers binaris (opcional)
data: Buffer,
mimeType: "image/png"
},
pairedItem: {
// Metadata per tracking
item: 0
}
},
{
json: {
id: 2,
name: "Maria",
email: "maria@example.com"
}
}
]
Transformació de dades entre nodes:
[HTTP Request]
Output:
[
{json: {id: 1, first_name: "Joan", last_name: "Garcia"}},
{json: {id: 2, first_name: "Maria", last_name: "Lopez"}}
]
↓
[Set Node]
Configuration:
full_name = {{$json.first_name}} {{$json.last_name}}
Output:
[
{json: {full_name: "Joan Garcia"}},
{json: {full_name: "Maria Lopez"}}
]
3.2. Workflows bàsics
Creació del primer workflow
Pas a pas:
-
Crear workflow:
-
Afegir trigger:
-
Afegir acció:
-
Afegir transformació:
-
Executar:
Connexió entre nodes
Tipus de connexions:
1. Main Output (sortida principal)
2. Multiple Outputs (sortides múltiples)
3. Multiple Inputs (múltiples entrades)
Best practices:
✅ Noms descriptius:
"Fetch GitHub User" → "Transform Data" → "Save to DB"
✅ Organització visual:
Flux d'esquerra a dreta
Alinea nodes verticalm ent
Usa notes per a seccions
❌ Evitar:
Noms genèrics: "HTTP Request 1", "Function 2"
Crossing lines (dificulta lectura)
Workflows massa grans (millor subworkflows)
Execució manual vs automàtica
Execució Manual:
Trigger: Manual Trigger
Quan: User click "Execute Workflow"
Ús:
- Desenvolupament
- Testing
- Execucions puntuals
Execució Automàtica - Schedule:
Trigger: Schedule Trigger
Configuració:
Cron: 0 9 * * * (cada dia 9AM)
Timezone: Europe/Madrid
Workflow s'executa automàticament cada dia
Execució Automàtica - Webhook:
Trigger: Webhook
URL: https://n8n.company.com/webhook/process-order
Quan: Sistema extern crida el webhook
POST https://n8n.company.com/webhook/process-order
{
"order_id": 12345,
"customer": "joan@example.com"
}
Workflow s'executa immediatament
Visualització del flux de dades
Inspeccionar dades a cada node:
- Executar workflow
- Click a qualsevol node
- Veure pestanya "Output":
Exemple de visualització:
[HTTP Request]
Output (2 items):
Item 1:
{
"id": 1,
"name": "Product A",
"price": 29.99
}
Item 2:
{
"id": 2,
"name": "Product B",
"price": 49.99
}
↓
[Function: Apply Tax]
Output (2 items):
Item 1:
{
"id": 1,
"name": "Product A",
"price": 29.99,
"price_with_tax": 36.29
}
Item 2:
{
"id": 2,
"name": "Product B",
"price": 49.99,
"price_with_tax": 60.49
}
Debugging visual:
- ✅ Veure dades a cada pas
- ✅ Identificar on falla el workflow
- ✅ Verificar transformacions
- ✅ Testing iteratiu
3.3. Dades a N8N
Estructura JSON de les dades
Format estàndard:
// Un sol item
{
json: {
// Les teves dades
user_id: 123,
name: "Joan Garcia",
email: "joan@example.com",
orders: [
{id: 1, total: 100},
{id: 2, total: 200}
]
},
binary: {}, // Opcional: fitxers
pairedItem: {item: 0} // Metadata
}
// Múltiples items (array)
[
{json: {user_id: 123, name: "Joan"}},
{json: {user_id: 456, name: "Maria"}},
{json: {user_id: 789, name: "Pere"}}
]
Nivells d'accés:
// Nivell 1: Item complet
$input.item
// Nivell 2: JSON data
$json
// Nivell 3: Fields
$json.user_id
$json.name
$json.orders[0].total
// Nivell 4: Nested
$json.address.city
$json.metadata.tags[2]
Items i arrays d'items
Processar múltiples items:
// Function Node
const items = $input.all(); // Obtenir tots els items
const processed = items.map(item => {
const data = item.json;
return {
json: {
user: data.name,
total_orders: data.orders.length,
total_spent: data.orders.reduce((sum, o) => sum + o.total, 0)
}
};
});
return processed;
Split vs Iterate:
ABANS Split In Batches:
Input: 1000 items
DESPRÉS Split In Batches (batch size: 100):
Iteration 1: 100 items
Iteration 2: 100 items
...
Iteration 10: 100 items
Merge Multiple Items:
// Input 1: User data
[{json: {id: 1, name: "Joan"}}]
// Input 2: Order data
[{json: {user_id: 1, total: 100}}]
// Merge on 'id' = 'user_id'
// Output:
[{json: {id: 1, name: "Joan", total: 100}}]
Accés a dades amb expressions
Sintaxi bàsica:
// Node actual
{{$json.field}}
// Node específic
{{$node["Node Name"].json.field}}
// Item específic
{{$item(0).json.field}} // Primer item
{{$item(1).json.field}} // Segon item
// Tot el input
{{$input.all()}}
Operacions:
// Matemàtiques
{{$json.price * 1.21}}
{{$json.quantity + 10}}
{{($json.total - $json.discount) / 100}}
// Strings
{{$json.name.toLowerCase()}}
{{$json.email.split('@')[1]}} // Dominio
{{"Hello " + $json.name}}
// Arrays
{{$json.tags.length}}
{{$json.tags[0]}}
{{$json.tags.join(', ')}}
// Condicionals (ternary)
{{$json.age >= 18 ? 'adult' : 'minor'}}
{{$json.stock > 0 ? 'available' : 'out of stock'}}
Funcions integrades:
// Data/hora
{{$now}} // Unix timestamp
{{$today}} // Data actual
{{$now.toISO()}} // ISO format
{{$now.plus({days: 7})}} // +7 dies
// Formatació
{{$json.price.toFixed(2)}} // 2 decimals
{{$json.name.toUpperCase()}} // MAJúSCULES
{{$json.email.includes('@gmail.com')}} // Boolean
// JSON
{{JSON.stringify($json)}}
{{JSON.parse($json.string_field)}}
Variables d'entorn
Accés a variables:
// A N8N Cloud o amb variables configurades
{{$env.API_KEY}}
{{$env.DATABASE_URL}}
{{$env.SMTP_HOST}}
Definir variables (docker-compose.yml):
services:
n8n:
environment:
- API_KEY=sk_live_abc123
- DATABASE_URL=postgres://user:pass@db:5432/mydb
Ús en nodes:
// HTTP Request
URL: {{$env.API_BASE_URL}}/users
Headers:
Authorization: Bearer {{$env.API_KEY}}
// PostgreSQL
Host: {{$env.DB_HOST}}
Database: {{$env.DB_NAME}}
Best practices:
✅ Secrets a variables d'entorn
✅ Diferents .env per entorn (dev, staging, prod)
✅ Mai hardcodejar credencials
❌ API keys directament al workflow
❌ Passwords en clar
Paràmetres dinàmics
Expressions a qualsevol camp:
HTTP Request:
Method: GET
URL: https://api.company.com/users/{{$json.user_id}}
Headers:
X-Request-ID: {{$now.toUnixInteger()}}
X-User-Email: {{$json.email}}
Dinàmic vs Estàtic:
// ❌ Estàtic (no canvia)
URL: https://api.company.com/users/123
// ✅ Dinàmic (usa dades del workflow)
URL: https://api.company.com/users/{{$json.user_id}}
Expressions complexes:
// Conditional URL
URL: {{$json.environment === 'prod'
? 'https://api.company.com'
: 'https://api-staging.company.com'}}/users
// Dynamic query params
URL: https://api.company.com/search?q={{$json.query}}&limit={{$json.limit || 10}}
// Array to comma-separated
Tags: {{$json.tags.join(',')}}
3.4. Testing i debugging
Execució pas a pas
Mètode 1: Execute Node (recomanat per debugging)
1. Crear workflow
2. Configurar primer node (trigger)
3. Click "Execute Node" NOMÉS al primer node
4. Veure output
5. Configurar segon node
6. Click "Execute Node" al segon node
7. Repetir per cada node
Avantatges: - ✅ Veus resultat de cada pas - ✅ No necessites executar tot - ✅ Ideal per desenvolupament
Mètode 2: Execute Workflow (testing complet)
Inspecció de dades a cada node
Pestanyes disponibles:
1. INPUT:
2. OUTPUT:
3. JSON:
4. TABLE:
5. BINARY:
Exemple d'inspecció:
Node: HTTP Request
Output: 5 items
TABLE view:
| id | name | email | status |
|-----|-----------|---------------------|---------|
| 1 | Joan | joan@example.com | active |
| 2 | Maria | maria@example.com | active |
| 3 | Pere | pere@example.com | pending |
| 4 | Anna | anna@example.com | active |
| 5 | Marc | marc@example.com | inactive|
JSON view:
[
{
"json": {
"id": 1,
"name": "Joan",
"email": "joan@example.com",
"status": "active"
}
},
...
]
Mock data per a testing
Crear dades de prova:
Mètode 1: Manual Trigger + Set Node
[Manual Trigger]
↓
[Set Node]
Items: Multiple
Item 1:
user_id: 1
name: "Joan"
email: "joan@test.com"
Item 2:
user_id: 2
name: "Maria"
email: "maria@test.com"
↓
[Rest of workflow...]
Mètode 2: Function Node amb dades mock
// Generar dades de test
const mockUsers = [
{id: 1, name: "Joan", age: 30, city: "Barcelona"},
{id: 2, name: "Maria", age: 25, city: "Girona"},
{id: 3, name: "Pere", age: 35, city: "Tarragona"},
];
return mockUsers.map(user => ({json: user}));
Mètode 3: Pinned Data
1. Executar node una vegada amb dades reals
2. Click "Pin Data" al output
3. Les dades queden fixades
4. Següents execucions usen dades pinnades
5. Útil per a:
- Testing sense cridar API cada vegada
- Desenvolupament offline
- Dades consistents per a testing
Logs i manejo d'errors
Nivells de log:
Veure logs:
# Docker
docker logs -f n8n
# Docker Compose
docker compose logs -f n8n
# Filtrar per nivell
docker logs n8n 2>&1 | grep ERROR
Error handling a workflows:
1. Continue On Fail (node level)
Node Configuration:
Continue On Fail: true
Comportament:
- Si node falla, workflow continua
- Error es pot capturar després
2. Error Trigger (workflow level)
3. Try-Catch pattern
[Try Process]
↓
[IF: Success?] ──true──> [Continue workflow]
│
└──false──> [Error Handler] → [Retry] or [Alert]
Exemple complet d'error handling:
[HTTP Request]
Settings:
Continue On Fail: true
↓
[IF Node]
Condition: {{$json.error}} not exists
↓
true ──> [Process Success]
│
false ─> [Function: Log Error]
↓
[Slack: Alert Team]
↓
[Retry (Wait + Loop)]
Re-execució de workflows
Re-executar workflow complet:
Re-executar des d'un node específic:
Useful per a: - Errors temporals (API down) - Després de fix de bugs - Testing de canvis
Resum Unitat 3:
Hem après: 1. Tipus de nodes i les seves funcions 2. Com crear i connectar workflows 3. Estructura de dades JSON a N8N 4. Expressions per accedir i manipular dades 5. Tècniques de testing i debugging
Conceptes clau: - Nodes són els blocs de construcció - Tot són arrays d'items en format JSON - Expressions {{...}} permeten dinamisme - Execute Node és millor per debugging - Error handling és essencial
Pròxims passos: A la Unitat 4 explorarem nodes més avançats per a transformacions complexes i control de flux sofisticat.