Salta el contingut

Activitats Pràctiques N8N

Curs d'Especialització en Big Data

ACTIVITAT 0: Instal·lació de N8N

Objectiu

Instal·lar i configurar N8N a l'entorn local utilitzant Docker.

Requisits previs

  • Docker instal·lat (versió 20.10 o superior)
  • Docker Compose instal·lat
  • 2GB RAM mínim
  • Port 5678 disponible

Part A: Instal·lació bàsica amb Docker

Passos:

  1. Instal·lació ràpida amb Docker: 

    docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n

  2. Accedir a N8N:

  3. Obrir navegador a: http://localhost:5678
  4. Crear usuari administrador

  5. Configurar email i contrasenya

  6. Verificar instal·lació:

  7. Crear un workflow de prova
  8. Afegir node "Manual Trigger"
  9. Afegir node "Set"
  10. Executar el workflow

Part B: Instal·lació amb Docker Compose (Recomanat)

Pas 1: Crear estructura de directoris 

mkdir n8n-bigdata
cd n8n-bigdata
mkdir n8n_data

Pas 2: Crear fitxer docker-compose.yml 

version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=la_teva_contrasenya_segura
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - NODE_ENV=production
      - WEBHOOK_URL=http://localhost:5678/
      - GENERIC_TIMEZONE=Europe/Madrid
      - TZ=Europe/Madrid
    volumes:
      - ./n8n_data:/home/node/.n8n

Pas 3: Iniciar N8N 

docker-compose up -d

Pas 4: Veure logs 

docker-compose logs -f n8n

Pas 5: Aturar N8N 

docker-compose down

Part C: Instal·lació amb PostgreSQL (Producció)

Crear fitxer docker-compose.yml complet: 

version: '3.8'

services:
  postgres:
    image: postgres:15
    container_name: n8n-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=n8n_password
      - POSTGRES_DB=n8n
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U n8n']
      interval: 5s
      timeout: 5s
      retries: 10

  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=n8n_password
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=la_teva_contrasenya_segura
      - WEBHOOK_URL=http://localhost:5678/
      - GENERIC_TIMEZONE=Europe/Madrid
    volumes:
      - ./n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

volumes:
  postgres_data:

Lliurables

  • Captura de pantalla del dashboard de N8N
  • Captura del primer workflow creat
  • Fitxer docker-compose.yml utilitzat
  • Document amb els problemes trobats i solucions

ACTIVITAT 1: Primer Workflow - Hola Món

Objectiu

Familiaritzar-se amb la interfície de N8N i crear un workflow bàsic.

Descripció

Crear un workflow que s'executi manualment i mostri un missatge personalitzat.

Passos

  1. Crear nou workflow:
  2. Click a "Add workflow"

  3. Nom: "01_Hola_Mon"

  4. Afegir nodes:

  5. Node 1: Manual Trigger

  6. Node 2: Set

    • Configurar: message = "Hola des de N8N"
    • Afegir camp: timestamp = {{ $now }}
    • Afegir camp: usuari = "el_teu_nom"

  7. Executar i verificar:

  8. Click a "Execute Node" a cada node
  9. Verificar el output en JSON

Repte addicional

  • Afegir un node HTTP Request que cridi a https://api.github.com/users/el_teu_usuari
  • Combinar les dades amb Set

Lliurables

  • Workflow exportat en JSON
  • Captures de pantalla del resultat

ACTIVITAT 2: Pipeline ETL - API a Base de Dades

Objectiu

Crear un pipeline ETL que extregui dades d'una API pública, les transformi i les carregui en una base de dades PostgreSQL.

Descripció

Extreure dades d'usuaris d'una API (JSONPlaceholder), netejar i transformar les dades, i carregar-les a PostgreSQL.

Part A: Preparació de la base de dades

Crear contenidor PostgreSQL: 

docker run --name n8n-postgres-test \
  -e POSTGRES_PASSWORD=postgres \
  -e POSTGRES_DB=n8n_test \
  -p 5432:5432 \
  -d postgres:15

Crear taula: 

CREATE TABLE usuaris (
    id SERIAL PRIMARY KEY,
    user_id INTEGER UNIQUE,
    nom VARCHAR(100),
    username VARCHAR(50),
    email VARCHAR(100),
    ciutat VARCHAR(100),
    empresa VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Part B: Configurar credencials a N8N

  1. Credentials > New Credential
  2. Seleccionar Postgres
  3. Configurar:
  4. Host: localhost (o IP del contenidor)
  5. Database: n8n_test
  6. User: postgres
  7. Password: postgres
  8. Port: 5432

Part C: Crear el workflow ETL

Nodes del workflow:

  1. Schedule Trigger
  2. Configurar: cada 1 hora

  3. Per testing: usar Manual Trigger

  4. HTTP Request - Extract

  5. Method: GET
  6. URL: https://jsonplaceholder.typicode.com/users

  7. Name: "Extreure_Usuaris"

  8. Function - Transform 

    // Netejar i transformar dades
const items = $input.all();

return items.map(item => {
  const data = item.json;
  return {
    json: {
      user_id: data.id,
      nom: data.name,
      username: data.username,
      email: data.email,
      ciutat: data.address.city,
      empresa: data.company.name
    }
  };
});

  9. Postgres - Load

  10. Operation: Insert
  11. Table: usuaris
  12. Columns: automàtic
  13. Options > On Conflict: "Update"

Part D: Verificació

SELECT * FROM usuaris;
SELECT COUNT(*) FROM usuaris;
SELECT ciutat, COUNT(*) as total FROM usuaris GROUP BY ciutat;

Repte addicional

  • Afegir node de validació abans de carregar
  • Implementar gestió d'errors
  • Afegir logs a una taula separada
  • Crear un report d'execució que s'enviï per email

Lliurables

  • Workflow exportat
  • Script SQL amb l'estructura de taules
  • Captures de dades carregades a PostgreSQL
  • Document explicant les transformacions realitzades

ACTIVITAT 3: Web Scraping i Anàlisi de Dades

Objectiu

Extreure dades d'una pàgina web, processar-les i generar estadístiques.

Descripció

Crear un workflow que extregui informació de productes d'una botiga online (ex: Books to Scrape) i analitzi preus.

Passos

  1. HTTP Request - Extracció
  2. URL: http://books.toscrape.com/

  3. Method: GET

  4. HTML Extract

  5. Configurar selectors CSS per a:

    • Títol del llibre
    • Preu
    • Rating
    • Disponibilitat

  6. Function - Processament 

    const items = $input.all();

return items.map(item => {
  const preu = parseFloat(item.json.preu.replace('£', ''));
  const rating = item.json.rating;

  return {
    json: {
      titol: item.json.titol,
      preu: preu,
      rating: rating,
      categoria: 'Llibres',
      assequible: preu < 30 ? 'Sí' : 'No'
    }
  };
});

  7. Aggregate - Estadístiques

  8. Calcular preu mitjà
  9. Preu màxim i mínim

  10. Comptar per rating

  11. Output

  12. Enviar resultats per email
  13. O desar en CSV

Lliurables

  • Workflow complet
  • CSV amb les dades extretes
  • Document amb anàlisi de resultats

ACTIVITAT 4: Pipeline de Dades en Temps Real

Objectiu

Crear un pipeline que processi dades en temps real mitjançant webhooks.

Descripció

Simular un sistema d'esdeveniments que rep dades de sensors IoT, les valida i emmagatzema.

Part A: Crear webhook receptor

  1. Webhook Trigger
  2. Path: /dades-sensor
  3. Method: POST

  4. Configurar resposta personalitzada

  5. Function - Validació 

    const items = $input.all();

return items.map(item => {
  const data = item.json;

  // Validar estructura
  if (!data.sensor_id || !data.temperatura || !data.timestamp) {
    throw new Error('Dades incompletes');
  }

  // Validar rangs
  if (data.temperatura < -50 || data.temperatura > 100) {
    throw new Error('Temperatura fora de rang');
  }

  return {
    json: {
      ...data,
      validat: true,
      processat_a: new Date().toISOString()
    }
  };
});

  6. IF - Alerta de temperatura

  7. Condició: temperatura > 80
  8. True: enviar alerta

  9. False: continuar

  10. PostgreSQL - Emmagatzemar

  11. Insert a taula lectures_sensors

Part B: Crear script de prova

Fitxer test_webhook.py: 

import requests
import json
import random
import time
from datetime import datetime

webhook_url = "http://localhost:5678/webhook/dades-sensor"

def generar_dades_sensor():
    return {
        "sensor_id": f"SENSOR_{random.randint(1, 10)}",
        "temperatura": round(random.uniform(20, 90), 2),
        "humitat": round(random.uniform(30, 80), 2),
        "timestamp": datetime.now().isoformat()
    }

# Enviar 10 esdeveniments
for i in range(10):
    dades = generar_dades_sensor()
    resposta = requests.post(webhook_url, json=dades)
    print(f"Esdeveniment {i+1}: {resposta.status_code} - Temp: {dades['temperatura']}°C")
    time.sleep(2)

Lliurables

  • Workflow amb webhook
  • Script de prova Python
  • Captures de dades rebudes
  • Anàlisi d'alertes generades

ACTIVITAT 5: Integració amb APIs d'IA

Objectiu

Integrar serveis d'IA per enriquir dades automàticament.

Descripció

Crear un workflow que analitzi sentiment de comentaris de productes.

Requisits

  • Compte a OpenAI o Hugging Face (API gratuïta disponible)

Part A: Workflow d'anàlisi de sentiment

  1. Manual Trigger amb dades de prova 

    [
  {"comentari": "Aquest producte és excel·lent, molt recomanat"},
  {"comentari": "No funciona bé, molt decebedor"},
  {"comentari": "Preu raonable, qualitat acceptable"}
]

  2. HTTP Request - IA API

  3. Configurar crida a API de sentiment

  4. Processar cada comentari

  5. Function - Classificar 

    const items = $input.all();

return items.map(item => {
  const sentiment = item.json.sentiment_score;
  let classificacio;

  if (sentiment > 0.6) {
    classificacio = 'Positiu';
  } else if (sentiment < 0.4) {
    classificacio = 'Negatiu';
  } else {
    classificacio = 'Neutral';
  }

  return {
    json: {
      comentari: item.json.comentari,
      sentiment_score: sentiment,
      classificacio: classificacio,
      analitzat_a: new Date().toISOString()
    }
  };
});

  6. Split In Batches

  7. Agrupar per classificació

  8. Switch

  9. Rutes segons sentiment
  10. Diferents accions per cada cas

Part B: Casos d'ús estesos

Opcions addicionals: - Anàlisi d'imatges amb Vision APIs - Extracció d'entitats de textos - Traducció automàtica - Generació de resums

Lliurables

  • Workflow funcional
  • Exemples d'anàlisis realitzades
  • Comparativa de diferents APIs d'IA

ACTIVITAT 6: Monitoratge i Alertes Automàtiques

Objectiu

Crear un sistema de monitoratge que verifiqui l'estat de serveis i generi alertes.

Descripció

Monitor que verifica APIs públiques i envia notificacions si hi ha problemes.

Workflow

  1. Schedule Trigger

  2. Cada 5 minuts

  3. HTTP Request - Check Services (múltiples)

  4. URL 1: https://api.github.com/status
  5. URL 2: https://httpstat.us/200

  6. URL 3: Altres serveis

  7. Function - Avaluació 

    const items = $input.all();
const fallades = [];

items.forEach(item => {
  if (item.json.statusCode !== 200) {
    fallades.push({
      servei: item.json.url,
      estat: item.json.statusCode,
      error: item.json.error || 'Error desconegut',
      timestamp: new Date().toISOString()
    });
  }
});

return fallades.length > 0 
  ? [{ json: { estat: 'FALLADA', fallades } }]
  : [{ json: { estat: 'OK', verificats: items.length } }];

  8. IF - Hi ha fallades?

  9. True: Enviar alerta

  10. False: Log success

  11. Accions d'alerta:

  12. Email notification
  13. Slack message
  14. Desar a base de dades

Part B: Dashboard d'estat

Crear taula de logs: 

CREATE TABLE verificacions_serveis (
    id SERIAL PRIMARY KEY,
    nom_servei VARCHAR(100),
    estat VARCHAR(20),
    temps_resposta_ms INTEGER,
    verificat_a TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Lliurables

  • Workflow de monitoratge
  • Historial de verificacions realitzades
  • Exemples d'alertes generades

ACTIVITAT 7: Pipeline de Data Warehouse

Objectiu

Crear un pipeline complet de càrrega a un data warehouse simulat.

Descripció

ETL des de múltiples fonts cap a un data warehouse (PostgreSQL simulant DWH).

Arquitectura

[API 1] ──┐
[API 2] ──┼──> [Transform] ──> [Stage] ──> [DWH]
[CSV]   ──┘

Part A: Crear estructura DWH

-- Taules staging
CREATE SCHEMA staging;

CREATE TABLE staging.vendes_raw (
    font VARCHAR(50),
    dades JSONB,
    carregat_a TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Taules DWH
CREATE SCHEMA dwh;

CREATE TABLE dwh.fact_vendes (
    venda_id SERIAL PRIMARY KEY,
    producte_id INTEGER,
    client_id INTEGER,
    import DECIMAL(10,2),
    data_venda DATE,
    sistema_origen VARCHAR(50)
);

CREATE TABLE dwh.dim_productes (
    producte_id SERIAL PRIMARY KEY,
    nom_producte VARCHAR(200),
    categoria VARCHAR(100),
    preu DECIMAL(10,2)
);

Part B: Workflow de càrrega

  1. Schedule Trigger - Diari a les 2 AM

  2. Subworkflow: Extract des d'API 1

  3. HTTP Request
  4. Transform

  5. Load a staging

  6. Subworkflow: Extract des de CSV

  7. Read Binary File
  8. Spreadsheet File
  9. Transform

  10. Load a staging

  11. Function: Merge i neteja 

    // Eliminar duplicats
// Validar dades
// Normalitzar formats

  12. Postgres: Load a DWH

  13. Inserir a fact tables

  14. Actualitzar dimension tables

  15. Function: Data quality checks 

    // Comptar registres
// Validar integritat referencial
// Verificar rangs de valors

  16. Notification: Resultat

  17. Email amb resum
  18. Slack amb mètriques

Lliurables

  • Workflow complet del pipeline
  • Scripts SQL d'estructura
  • Documentació del procés
  • Report d'execució amb mètriques

ACTIVITAT 8: Projecte Final Integrador

Objectiu

Desenvolupar un projecte complet que integri tots els coneixements adquirits.

Opcions de projecte

Opció A: Sistema d'Anàlisi de Xarxes Socials

  • Extreure dades d'APIs de xarxes socials
  • Anàlisi de sentiment amb IA
  • Generació de reports automatitzats
  • Dashboard de mètriques en temps real

Opció B: Pipeline d'E-commerce Analytics

  • Integració amb plataforma e-commerce
  • ETL de productes, vendes, clients
  • Data warehouse dimensional
  • Alertes d'stock i vendes
  • Reports automatitzats

Opció C: Monitor de Mercat Financer

  • Extracció de dades d'APIs financeres
  • Anàlisi de tendències
  • Alertes de preus
  • Prediccions bàsiques
  • Visualització de dades

Requisits mínims

  1. Almenys 3 fonts de dades diferents
  2. Transformacions complexes amb JavaScript/Python
  3. Emmagatzematge en base de dades
  4. Integració amb IA (opcional)
  5. Sistema d'alertes
  6. Documentació completa
  7. Proves i validació

Estructura de lliurament

projecte-final/
├── README.md                 # Descripció del projecte
├── arquitectura.md          # Diagrama i explicació
├── workflows/
│   ├── pipeline_principal.json
│   ├── subworkflow_1.json
│   └── ...
├── sql/
│   ├── schema.sql
│   └── queries.sql
├── scripts/
│   └── test_data.py
├── docs/
│   ├── manual_usuari.md
│   └── manual_tecnic.md
└── presentacio.pdf

Criteris d'avaluació

  • Funcionalitat (30%): El sistema funciona correctament
  • Complexitat tècnica (25%): Ús avançat de N8N
  • Disseny d'arquitectura (20%): Arquitectura escalable i mantenible
  • Qualitat del codi (15%): Codi net i documentat
  • Documentació (10%): Documentació completa i clara

Lliurables

  • Projecte complet segons estructura
  • Vídeo demo (5-10 minuts)
  • Presentació tècnica
  • Codi font exportat

Recursos i Eines Addicionals

APIs públiques per practicar

  • JSONPlaceholder: https://jsonplaceholder.typicode.com/
  • OpenWeather: https://openweathermap.org/api
  • CoinGecko: https://www.coingecko.com/en/api
  • GitHub API: https://api.github.com/
  • REST Countries: https://restcountries.com/

Eines complementàries

  • Postman: testing d'APIs
  • DBeaver: gestió de bases de dades
  • VS Code: edició de scripts
  • Git: control de versions

Bases de dades per practicar

  • PostgreSQL (Docker)
  • MongoDB (Docker)
  • MySQL (Docker)
  • Redis (Docker)

Versió: 1.0
Autor: Francesc - Institut Sa Palomera
Curs: Especialització en Big Data