Premier workflow n8n en 30 minutes : tuto débutant complet

version: '3.8'

services:
  n8n-pipeline:
    image: docker.n8n.io/n8nio/n8n
    container_name: workflow-engine
    restart: unless-stopped
    ports:
      - "5678:5678"
    volumes:
      - n8n_storage:/home/node/.n8n
    environment:
      - N8N_SECURE_COOKIE=false
      - WEBHOOK_URL=http://localhost:5678/
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=168

volumes:
  n8n_storage:
    driver: local

&current=temperature_2m,weathercode&timezone=Europe/Paris`

• Response Format: JSON

Architecture Rationale: Public APIs without authentication requirements simplify credential management. The response structure follows a predictable schema, enabling reliable field extraction in downstream nodes. For production environments requiring authenticated endpoints, n8n's credential store isolates secrets from workflow definitions, preventing accidental exposure in version control or export files.

Step 4: Data Transformation & Expression Evaluation

Raw API responses rarely match downstream payload requirements. The transformation node maps incoming fields to a structured output using an expression engine. n8n evaluates expressions at runtime, resolving references to previous node outputs.

Node Configuration:

• Type: Edit Fields
• Mode: Manual Mapping
• Field Name: formatted_output
• Value Expression: 🌡️ Morning Report: {{ $json.current.temperature_2m }}°C | Condition Code: {{ $json.current.weathercode }}

Why this approach: The expression syntax {{ $json.xxx }} directly references the JSON payload from the immediate predecessor node. This eliminates intermediate parsing steps and reduces cognitive overhead. The engine automatically handles type coercion, null safety, and string interpolation. For complex transformations, multiple fields can be mapped independently, enabling granular control over payload structure.

Step 5: Channel Delivery

The final node routes the formatted payload to a messaging platform via a webhook endpoint. Webhooks provide a lightweight, stateless delivery mechanism that requires no persistent connection or polling.

Node Configuration:

• Type: HTTP Request
• Method: POST
• URL: [Discord Webhook URL]
• Body Content Type: JSON
• JSON Body: {"content": "{{ $json.formatted_output }}"}

Architecture Rationale: Webhook delivery decouples the workflow from channel-specific SDKs or authentication flows. The messaging platform handles rate limiting, message persistence, and fan-out distribution. By structuring the payload as a simple JSON object, the workflow remains compatible with any service that accepts standard HTTP POST requests.

Step 6: Execution Activation

Workflows remain in a draft state until explicitly activated. The activation toggle transitions the engine from manual execution mode to scheduled listening mode. Once active, the scheduler registers the cron expression with the internal event loop, and the workflow executes autonomously at the defined interval.

Why this matters: Separating development/testing from production execution prevents accidental runs during configuration. Manual execution (Execute Step) validates individual nodes without triggering the scheduler or consuming scheduled execution slots. This isolation is essential for debugging complex pipelines without disrupting production schedules.

Pitfall Guide

1. Confusing Manual Execution with Scheduled Activation

   • Explanation: Clicking "Execute Node" or "Execute Workflow" runs the pipeline immediately in a test context. It does not register the schedule or transition the workflow to production mode.
   • Fix: Always verify the activation toggle in the canvas header. Manual execution is for validation; the toggle controls autonomous scheduling.

2. Ignoring Credential Isolation

   • Explanation: Workflow exports contain node configurations but deliberately exclude stored credentials. Teams sometimes attempt to hardcode API keys directly into node fields, bypassing the credential store.
   • Fix: Use the built-in credential manager for all sensitive values. Exported workflows remain safe for version control, and credentials can be rotated independently of workflow definitions.

3. Expression Mode Mismatch

   • Explanation: The expression engine only evaluates fields when explicitly toggled to expression mode. Leaving a field in text mode causes the engine to treat {{ $json.xxx }} as a literal string.
   • Fix: Always click the expression toggle (=) before entering dynamic references. Validate the preview panel to confirm runtime resolution before saving.

4. Webhook Environment URL Confusion

   • Explanation: Webhook listeners often provide separate test and production endpoints. Test URLs typically fire once and expire, while production URLs remain active. Using a test URL in a scheduled workflow causes silent failures after the first execution.
   • Fix: Reserve test URLs for manual validation. Switch to the production webhook URL before activating the workflow. Document the environment distinction in workflow comments.

5. Unbounded Execution History

   • Explanation: The engine stores complete execution logs by default. Over time, this consumes significant disk space and degrades UI performance.
   • Fix: Configure EXECUTIONS_DATA_PRUNE and EXECUTIONS_DATA_MAX_AGE environment variables. Set retention policies aligned with compliance requirements and storage capacity.

6. Missing Error Handling & Retry Logic

   • Explanation: Network timeouts, API rate limits, and malformed responses cause silent failures when no error handling is configured. The workflow stops at the failing node without notification.
   • Fix: Attach an Error Trigger node to critical steps. Configure retry policies with exponential backoff for HTTP requests. Route failures to a notification channel for immediate visibility.

7. Hardcoding Geographic or Environmental Parameters

   • Explanation: Embedding coordinates, timezones, or thresholds directly in node URLs makes workflows brittle and difficult to reuse across environments.
   • Fix: Extract static parameters into environment variables or a configuration node. Use expression references to inject values dynamically, enabling environment-specific overrides without modifying workflow logic.

Production Bundle

Action Checklist

• Initialize Docker Compose with persistent volume and execution pruning configuration
• Verify timezone alignment between host system and scheduler node settings
• Store all API keys and webhook secrets in the credential manager, never in node fields
• Toggle expression mode (=) for every dynamic field and validate preview output
• Attach error handling nodes to external API calls and webhook deliveries
• Configure execution history retention policies before activating production workflows
• Test with manual execution before switching the activation toggle to Active
• Document webhook environment URLs and rotate secrets on a scheduled basis

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Rapid prototyping or single-user automation	n8n Cloud trial or local Docker instance	Zero infrastructure overhead, immediate UI access	Free tier covers limited executions; scales to paid plans
High-volume scheduled jobs or internal data routing	Self-hosted Docker/Kubernetes deployment	Unlimited executions, full data residency, custom node support	Fixed infrastructure cost; scales with existing compute resources
Compliance-bound or air-gapped environments	Self-hosted with isolated network and credential vault	No external data transmission, full audit trail, secret isolation	Higher DevOps overhead; eliminates third-party data processing fees
Multi-team workflow sharing and version control	Self-hosted with Git integration and role-based access	Centralized repository, peer review, rollback capability	Requires CI/CD pipeline setup; reduces configuration drift

Configuration Template

# docker-compose.yml for production n8n deployment
version: '3.8'

services:
  workflow-engine:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n-production
    restart: unless-stopped
    ports:
      - "5678:5678"
    volumes:
      - n8n-data:/home/node/.n8n
    environment:
      - N8N_SECURE_COOKIE=true
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - WEBHOOK_URL=https://automation.yourdomain.com/
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=336
      - GENERIC_TIMEZONE=Europe/Paris
    networks:
      - automation-net

volumes:
  n8n-data:
    driver: local

networks:
  automation-net:
    driver: bridge

Quick Start Guide

1. Deploy the engine: Run docker compose up -d in a directory containing the configuration template. Verify the service is reachable at http://localhost:5678.
2. Initialize credentials: Navigate to Settings → Credentials. Add your Discord webhook URL and any API keys using the built-in credential manager. Never paste secrets directly into node fields.
3. Build the pipeline: Create a new workflow. Add a Schedule Trigger (daily, 09:00), an HTTP Request node (GET to Open-Meteo), an Edit Fields node (map temperature to a formatted string), and a final HTTP Request node (POST to Discord webhook).
4. Validate execution: Click "Execute Workflow" to run a manual test. Inspect each node's output panel to confirm data flows correctly and expressions resolve as expected.
5. Activate production mode: Toggle the workflow status to Active. The scheduler registers the cron expression, and the pipeline begins autonomous execution at the next scheduled interval. Monitor the Executions tab for the first automated run.