Automated Kubernetes Testing with Robot Framework, ArgoCD & With KinD Lifecycle

Description

Overview

This n8n workflow provides automated CI/CD testing for Kubernetes applications using KinD (Kubernetes in Docker). It creates temporary infrastructure, runs tests, and cleans up everything automatically.

Three-Phase Lifecycle

INIT Phase - Infrastructure Setup
Installs dependencies (sshpass, Docker, KinD)
Creates KinD cluster
Installs Helm and Nginx Ingress
Installs HAProxy for port forwarding
Deploys ArgoCD
Applies ApplicationSet

TEST Phase - Automated Testing
Downloads Robot Framework test script from GitLab
Installs Robot Framework and Browser library
Executes automated browser tests
Packages test results
Sends results via Telegram

DESTROY Phase - Complete Cleanup
Removes HAProxy
Deletes KinD cluster
Uninstalls KinD
Uninstalls Docker
Sends completion notification

Execution Modes

Full Pipeline Mode (progress_only = false)
> Automatically progresses through all phases: INIT → TEST → DESTROY

Single Phase Mode (progress_only = true)
> Executes only the specified phase and stops

Prerequisites

Local Environment (n8n Host)
n8n instance version 1.0 or higher
Community node n8n-nodes-robotframework installed
Network access to target host and GitLab
Minimum 4 GB RAM, 20 GB disk space

Remote Target Host
Linux server (Ubuntu, Debian, CentOS, Fedora, or Alpine)
SSH access with sudo privileges
Minimum 8 GB RAM (16 GB recommended)
20 GB** free disk space
Open ports: 22, 80, 60080, 60443, 56443

External Services
GitLab** account with OAuth2 application
Repository with test files (test.robot, config.yaml, demo-applicationSet.yaml)
Telegram Bot** for notifications
Telegram Chat ID

Setup Instructions

Step 1: Install Community Node

In n8n web interface, navigate to Settings → Community Nodes
Install n8n-nodes-robotframework
Restart n8n if prompted

Step 2: Configure GitLab OAuth2

Create GitLab OAuth2 Application
Log in to GitLab
Navigate to User Settings → Applications
Create new application with redirect URI: https://your-n8n-instance.com/rest/oauth2-credential/callback
Grant scopes: read_api, read_repository, read_user
Copy Application ID and Secret

Configure in n8n
Create new GitLab OAuth2 API credential
Enter GitLab server URL, Client ID, and Secret
Connect and authorize

Step 3: Prepare GitLab Repository

Create repository structure:

your-repo/
├── test.robot
├── config.yaml
├── demo-applicationSet.yaml
└── .gitlab-ci.yml

Upload your:
Robot Framework test script
KinD cluster configuration
ArgoCD ApplicationSet manifest

Step 4: Configure Telegram Bot

Create Bot
Open Telegram, search for @BotFather
Send /newbot command
Save the API token

Get Chat ID
For personal chat:
Send message to your bot
Visit: https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates
Copy the chat ID (positive number)

For group chat:
Add bot to group
Send message mentioning the bot
Visit getUpdates endpoint
Copy group chat ID (negative number)

Configure in n8n
Create Telegram API credential
Enter bot token
Save credential

Step 5: Prepare Target Host

Verify SSH access:
Test connection: ssh -p <port> <username>@<host_ip>
Verify sudo: sudo -v

The workflow will automatically install dependencies.

Step 6: Import and Configure Workflow

Import Workflow
Copy workflow JSON
In n8n, click Workflows → Import from File/URL
Import the JSON

Configure Parameters

Open Set Parameters node and update:

| Parameter | Description | Example |
|-----------|-------------|---------|
| target_host | IP address of remote host | 192.168.1.100 |
| target_port | SSH port | 22 |
| target_user | SSH username | ubuntu |
| target_password | SSH password | your_password |
| progress | Starting phase | INIT, TEST, or DESTROY |
| progress_only | Execution mode | true or false |
| KIND_CONFIG | Path to config.yaml | config.yaml |
| ROBOT_SCRIPT | Path to test.robot | test.robot |
| ARGOCD_APPSET | Path to ApplicationSet | demo-applicationSet.yaml |

> Security: Use n8n credentials or environment variables instead of storing passwords in the workflow.

Configure GitLab Nodes

For each of the three GitLab nodes:
Set Owner (username or organization)
Set Repository name
Set File Path (uses parameter from Set Parameters)
Set Reference (branch: main or master)
Select Credentials (GitLab OAuth2)

Configure Telegram Nodes

Send ROBOT Script Export Pack node:
Set Chat ID
Select Credentials

Process Finish Report node:
Update chat ID in command

Step 7: Test and Execute

Test individual components first
Run full workflow
Monitor execution (30-60 minutes total)

How to Use

Execution Examples

Complete Testing Pipeline
progress = "INIT"
progress_only = "false"
Flow: INIT → TEST → DESTROY

Setup Infrastructure Only
progress = "INIT"
progress_only = "true"
Flow: INIT → Stop

Test Existing Infrastructure
progress = "TEST"
progress_only = "false"
Flow: TEST → DESTROY

Cleanup Only
progress = "DESTROY"
Flow: DESTROY → Complete

Trigger Methods

1. Manual Execution
Open workflow in n8n
Set parameters
Click Execute Workflow

2. Scheduled Execution
Open Schedule Trigger node
Configure time (default: 1 AM daily)
Ensure workflow is Active

3. Webhook Trigger
Configure webhook in GitLab repository
Add webhook URL to GitLab CI

Monitoring Execution

In n8n Interface:
View progress in Executions tab
Watch node-by-node execution
Check output details

Via Telegram:
Receive test results after TEST phase
Receive completion notification after DESTROY phase

Execution Timeline:
| Phase | Duration |
|-------|----------|
| INIT | 15-25 minutes |
| TEST | 5-10 minutes |
| DESTROY | 5-10 minutes |

Understanding Test Results

After TEST phase, receive testing-export-pack.tar.gz via Telegram containing:

log.html - Detailed test execution log
report.html - Test summary report
output.xml - Machine-readable results
screenshots/ - Browser screenshots

To view:
Download .tar.gz from Telegram
Extract: tar -xzf testing-export-pack.tar.gz
Open report.html for summary
Open log.html for detailed steps

Success indicators:
All tests marked PASS
Screenshots show expected UI states
No error messages in logs

Failure indicators:
Tests marked FAIL
Error messages in logs
Unexpected UI states in screenshots

Configuration Files

test.robot

Robot Framework test script structure:
Uses Browser library
Connects to http://autotest.innersite
Logs in with autotest/autotest
Takes screenshots
Runs in headless Chromium

config.yaml

KinD cluster configuration:
1 control-plane node**
1 worker node**
Port mappings: 60080 (HTTP), 60443 (HTTPS), 56443 (API)
Kubernetes version: v1.30.2

demo-applicationSet.yaml

ArgoCD Application manifest:
Points to Git repository
Automatic sync enabled
Deploys to default namespace

gitlab-ci.yml

Triggers n8n workflow on commits:
Installs curl
Sends POST request to webhook

Troubleshooting

SSH Permission Denied

Symptoms:
Error: Permission denied (publickey,password)

Solutions:
Verify password is correct
Check SSH authentication method
Ensure user has sudo privileges
Use SSH keys instead of passwords

Docker Installation Fails

Symptoms:
Error: Package docker-ce is not available

Solutions:
Check OS version compatibility
Verify network connectivity
Manually add Docker repository

KinD Cluster Creation Timeout

Symptoms:
Error: Failed to create cluster: timed out

Solutions:
Check available resources (RAM/CPU/disk)
Verify Docker daemon status
Pre-pull images
Increase timeout

ArgoCD Not Accessible

Symptoms:
Error: Failed to connect to autotest.innersite

Solutions:
Check HAProxy status: systemctl status haproxy
Verify /etc/hosts entry
Check Ingress: kubectl get ingress -n argocd
Test port forwarding: curl http://127.0.0.1:60080

Robot Framework Tests Fail

Symptoms:
Error: Chrome failed to start

Solutions:
Verify Chromium installation
Check Browser library: rfbrowser show-trace
Ensure correct executablePath in test.robot
Install missing dependencies

Telegram Notification Not Received

Symptoms:
Workflow completes but no message

Solutions:
Verify Chat ID
Test Telegram API manually
Check bot status
Re-add bot to group

Workflow Hangs

Symptoms:
Node shows "Executing..." indefinitely

Solutions:
Check n8n logs
Test SSH connection manually
Verify target host status
Add timeouts to commands

Best Practices

Development Workflow

Test locally first
Run Robot Framework tests on local machine
Verify test script syntax

Version control
Keep all files in Git
Use branches for experiments
Tag stable versions

Incremental changes
Make small testable changes
Test each change separately

Backup data
Export workflow regularly
Save test results
Store credentials securely

Production Deployment

Separate environments
Dev: Frequent testing
Staging: Pre-production validation
Production: Stable scheduled runs

Monitoring
Set up execution alerts
Monitor host resources
Track success/failure rates

Disaster recovery
Document cleanup procedures
Keep backup host ready
Test restoration process

Security
Use SSH keys
Rotate credentials quarterly
Implement network segmentation

Maintenance Schedule

| Frequency | Tasks |
|-----------|-------|
| Daily | Review logs, check notifications |
| Weekly | Review failures, check disk space |
| Monthly | Update dependencies, test recovery |
| Quarterly | Rotate credentials, security audit |

Advanced Topics

Custom Configurations

Multi-node clusters:
Add more worker nodes for production-like environments
Configure resource limits
Add custom port mappings

Advanced testing:
Load testing with multiple iterations
Integration testing for full deployment pipeline
Chaos engineering with failure injection

Integration with Other Tools

Monitoring:
Prometheus for metrics collection
Grafana for visualization

Logging:
ELK stack for log aggregation
Custom dashboards

CI/CD Integration:
Jenkins pipelines
GitHub Actions
Custom webhooks

Resource Requirements

Minimum
| Component | CPU | RAM | Disk |
|-----------|-----|-----|------|
| n8n Host | 2 | 4 GB | 20 GB |
| Target Host | 4 | 8 GB | 20 GB |

Recommended
| Component | CPU | RAM | Disk |
|-----------|-----|-----|------|
| n8n Host | 4 | 8 GB | 50 GB |
| Target Host | 8 | 16 GB | 50 GB |

Useful Commands

KinD
List clusters: kind get clusters
Get kubeconfig: kind get kubeconfig --name automate-tst
Export logs: kind export logs --name automate-tst

Docker
List containers: docker ps -a --filter "name=automate-tst"
Enter control plane: docker exec -it automate-tst-control-plane bash
View logs: docker logs automate-tst-control-plane

Kubernetes
Get all resources: kubectl get all -A
Describe pod: kubectl describe pod -n argocd <pod-name>
View logs: kubectl logs -n argocd <pod-name> --follow
Port forward: kubectl port-forward -n argocd svc/argocd-server 8080:80

Robot Framework
Run tests: robot test.robot
Run specific test: robot -t "Test Name" test.robot
Generate report: robot --outputdir results test.robot

Additional Resources

Official Documentation
n8n**: https://docs.n8n.io
KinD**: https://kind.sigs.k8s.io
ArgoCD**: https://argo-cd.readthedocs.io
Robot Framework**: https://robotframework.org
Browser Library**: https://marketsquare.github.io/robotframework-browser

Community
n8n Community**: https://community.n8n.io
Kubernetes Slack**: https://kubernetes.slack.com
ArgoCD Slack**: https://argoproj.github.io/community/join-slack
Robot Framework Forum**: https://forum.robotframework.org

Related Projects
k3s**: Lightweight Kubernetes distribution
minikube**: Local Kubernetes alternative
Flux CD**: Alternative GitOps tool
Playwright**: Alternative browser automation