SlurpIT.io

SlurpIT.io is a network configuration management and orchestration platform designed to simplify network automation through intelligent API management, workflow automation, and configuration orchestration. It provides a unified interface for managing multi-vendor network environments.

Key Features

• Multi-vendor API Management: Unified interface for Cisco, Juniper, Arista, and other vendors
• Workflow Automation: Visual workflow builder for complex network operations
• Configuration Orchestration: Manage configurations across multiple devices simultaneously
• Real-time Monitoring: Live device status and configuration tracking
• Version Control: Track configuration changes with rollback capabilities
• RESTful APIs: Comprehensive API for integration with existing tools
• Template Management: Reusable configuration templates and snippets
• Audit Trail: Complete logging and audit capabilities

Typical Use Cases

• Configuration Management: Deploy and manage configurations across network devices
• Network Orchestration: Coordinate complex network changes and migrations
• API Integration: Simplify multi-vendor API interactions
• Workflow Automation: Automate repetitive network operations
• Change Management: Implement controlled configuration changes
• Compliance Management: Ensure network configurations meet compliance requirements
• Network Testing: Validate configurations before deployment

Getting Started

1. Platform Setup

1. Visit slurpit.io
2. Create an account and complete onboarding
3. Set up your organization and team structure
4. Configure initial device connections

Deployment Options

SlurpIT.io provides flexible deployment options to meet various organizational needs:

Cloud Deployment (SaaS)

• Instant Access: Sign up at slurpit.io for immediate platform access
• Fully Managed: Handled by SlurpIT.io team with automatic updates
• Enterprise Features: Advanced security, compliance, and scalability
• Global Availability: Accessible from anywhere with internet connectivity

On-Premise Deployment

SlurpIT.io can be deployed on your own infrastructure for maximum control and security:

Docker Deployment

# docker-compose.yml
version: '3.8'
services:
  slurpit:
    image: slurpit/slurpit:latest
    container_name: slurpit
    ports:
      - "8080:8080"
    environment:
      - SLURPIT_DATABASE_URL=postgresql://user:password@db:5432/slurpit
      - SLURPIT_REDIS_URL=redis://redis:6379
      - SLURPIT_SECRET_KEY=your-secret-key
      - SLURPIT_ENVIRONMENT=production
    volumes:
      - slurpit_data:/app/data
      - slurpit_configs:/app/configs
      - slurpit_logs:/app/logs
    depends_on:
      - db
      - redis
    restart: unless-stopped

  db:
    image: postgres:13
    container_name: slurpit-db
    environment:
      - POSTGRES_DB=slurpit
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:6-alpine
    container_name: slurpit-redis
    volumes:
      - redis_data:/data
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    container_name: slurpit-nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - slurpit
    restart: unless-stopped

volumes:
  slurpit_data:
  slurpit_configs:
  slurpit_logs:
  postgres_data:
  redis_data:

Terraform Deployment

# main.tf
terraform {
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "~> 3.0"
    }
    local = {
      source  = "hashicorp/local"
      version = "~> 2.0"
    }
  }
}

# Create Docker network
resource "docker_network" "slurpit_network" {
  name = "slurpit-network"
}

# Create volumes
resource "docker_volume" "slurpit_data" {
  name = "slurpit-data"
}

resource "docker_volume" "slurpit_configs" {
  name = "slurpit-configs"
}

resource "docker_volume" "postgres_data" {
  name = "postgres-data"
}

# PostgreSQL database
resource "docker_container" "slurpit_db" {
  name  = "slurpit-db"
  image = "postgres:13"

  networks_advanced {
    name = docker_network.slurpit_network.name
  }

  volumes {
    volume_name    = docker_volume.postgres_data.name
    container_path = "/var/lib/postgresql/data"
  }

  env = [
    "POSTGRES_DB=slurpit",
    "POSTGRES_USER=slurpit",
    "POSTGRES_PASSWORD=${var.db_password}"
  ]

  restart = "unless-stopped"
}

# Redis cache
resource "docker_container" "slurpit_redis" {
  name  = "slurpit-redis"
  image = "redis:6-alpine"

  networks_advanced {
    name = docker_network.slurpit_network.name
  }

  restart = "unless-stopped"
}

# SlurpIT application
resource "docker_container" "slurpit" {
  name  = "slurpit"
  image = "slurpit/slurpit:latest"

  networks_advanced {
    name = docker_network.slurpit_network.name
  }

  volumes {
    volume_name    = docker_volume.slurpit_data.name
    container_path = "/app/data"
  }

  volumes {
    volume_name    = docker_volume.slurpit_configs.name
    container_path = "/app/configs"
  }

  ports {
    internal = 8080
    external = 8080
  }

  env = [
    "SLURPIT_DATABASE_URL=postgresql://slurpit:${var.db_password}@slurpit-db:5432/slurpit",
    "SLURPIT_REDIS_URL=redis://slurpit-redis:6379",
    "SLURPIT_SECRET_KEY=${var.secret_key}",
    "SLURPIT_ENVIRONMENT=production"
  ]

  depends_on = [docker_container.slurpit_db, docker_container.slurpit_redis]
  restart    = "unless-stopped"
}

# Nginx reverse proxy
resource "docker_container" "slurpit_nginx" {
  name  = "slurpit-nginx"
  image = "nginx:alpine"

  networks_advanced {
    name = docker_network.slurpit_network.name
  }

  ports {
    internal = 80
    external = 80
  }

  ports {
    internal = 443
    external = 443
  }

  volumes {
    host_path      = "${path.module}/nginx.conf"
    container_path = "/etc/nginx/nginx.conf"
  }

  depends_on = [docker_container.slurpit]
  restart    = "unless-stopped"
}

# variables.tf
variable "db_password" {
  description = "Database password"
  type        = string
  sensitive   = true
}

variable "secret_key" {
  description = "SlurpIT secret key"
  type        = string
  sensitive   = true
}

# outputs.tf
output "slurpit_url" {
  description = "SlurpIT application URL"
  value       = "http://localhost:8080"
}

output "nginx_url" {
  description = "Nginx proxy URL"
  value       = "http://localhost"
}

Kubernetes Deployment

# slurpit-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: slurpit
  labels:
    app: slurpit
spec:
  replicas: 2
  selector:
    matchLabels:
      app: slurpit
  template:
    metadata:
      labels:
        app: slurpit
    spec:
      containers:
      - name: slurpit
        image: slurpit/slurpit:latest
        ports:
        - containerPort: 8080
        env:
        - name: SLURPIT_DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: slurpit-secrets
              key: database-url
        - name: SLURPIT_REDIS_URL
          value: "redis://slurpit-redis:6379"
        - name: SLURPIT_SECRET_KEY
          valueFrom:
            secretKeyRef:
              name: slurpit-secrets
              key: secret-key
        - name: SLURPIT_ENVIRONMENT
          value: "production"
        volumeMounts:
        - name: slurpit-data
          mountPath: /app/data
        - name: slurpit-configs
          mountPath: /app/configs
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
      volumes:
      - name: slurpit-data
        persistentVolumeClaim:
          claimName: slurpit-data-pvc
      - name: slurpit-configs
        persistentVolumeClaim:
          claimName: slurpit-configs-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: slurpit-service
spec:
  selector:
    app: slurpit
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: slurpit-data-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: slurpit-configs-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi

Deployment Considerations

Cloud vs On-Premise

• Cloud: Zero infrastructure management, automatic scaling, global availability
• On-Premise: Complete data control, custom integrations, air-gapped environments

Resource Requirements

• Minimum: 2 CPU cores, 4GB RAM, 50GB storage
• Recommended: 4 CPU cores, 8GB RAM, 200GB storage
• Database: PostgreSQL 12+ or MySQL 8+
• Cache: Redis 6+ (required for performance)
• Network: Stable connectivity to managed devices

Security Considerations

• Implement HTTPS/TLS encryption
• Use strong authentication and RBAC
• Secure database connections with SSL
• Regular security patches and updates
• Network segmentation and firewall rules
• Audit logging and monitoring

2. Device Integration

1. Add Network Devices: Connect your network devices to SlurpIT
2. Configure Credentials: Set up secure access credentials
3. Test Connectivity: Verify device connectivity and API access
4. Discover Capabilities: Automatically discover device features and APIs

3. Workflow Creation

# Example workflow definition
workflow:
  name: "Network Configuration Update"
  description: "Update network configurations across multiple devices"
  steps:
    - name: "Backup Current Configuration"
      action: "backup_config"
      devices: "{{ target_devices }}"

    - name: "Validate New Configuration"
      action: "validate_config"
      template: "new_config_template"

    - name: "Deploy Configuration"
      action: "deploy_config"
      devices: "{{ target_devices }}"
      template: "new_config_template"

    - name: "Verify Deployment"
      action: "verify_config"
      devices: "{{ target_devices }}"

4. API Integration

# Example API call to execute workflow
curl -X POST "https://api.slurpit.io/v1/workflows/execute" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "workflow_id": "config_update_workflow",
    "parameters": {
      "target_devices": ["router1", "router2", "switch1"],
      "config_template": "vlan_update_template"
    }
  }'

Integration Examples

Ansible Integration

# Use SlurpIT as configuration source
- name: Deploy network configuration via SlurpIT
  hosts: localhost
  gather_facts: no
  tasks:
    - name: Execute SlurpIT workflow
      uri:
        url: "https://api.slurpit.io/v1/workflows/execute"
        method: POST
        headers:
          Authorization: "Bearer {{ slurpit_api_token }}"
          Content-Type: "application/json"
        body_format: json
        body:
          workflow_id: "{{ workflow_id }}"
          parameters: "{{ workflow_parameters }}"
      register: workflow_result

    - name: Wait for workflow completion
      uri:
        url: "https://api.slurpit.io/v1/workflows/{{ workflow_result.json.workflow_run_id }}/status"
        method: GET
        headers:
          Authorization: "Bearer {{ slurpit_api_token }}"
      register: workflow_status
      until: workflow_status.json.status in ['completed', 'failed']
      retries: 30
      delay: 10

Terraform Integration

# Use SlurpIT for network configuration management
resource "slurpit_workflow_execution" "network_config" {
  workflow_id = "network_configuration_workflow"

  parameters = {
    target_devices = var.network_devices
    config_template = var.config_template
    environment = var.environment
  }

  depends_on = [aws_instance.network_devices]
}

output "workflow_status" {
  value = slurpit_workflow_execution.network_config.status
}

Python Integration

import requests
import json

class SlurpITClient:
    def __init__(self, api_token, base_url="https://api.slurpit.io/v1"):
        self.api_token = api_token
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_token}",
            "Content-Type": "application/json"
        }

    def execute_workflow(self, workflow_id, parameters=None):
        """Execute a SlurpIT workflow"""
        url = f"{self.base_url}/workflows/execute"
        payload = {
            "workflow_id": workflow_id,
            "parameters": parameters or {}
        }

        response = requests.post(url, headers=self.headers, json=payload)
        return response.json()

    def get_workflow_status(self, workflow_run_id):
        """Get workflow execution status"""
        url = f"{self.base_url}/workflows/{workflow_run_id}/status"
        response = requests.get(url, headers=self.headers)
        return response.json()

# Usage example
client = SlurpITClient("your_api_token")
result = client.execute_workflow("network_config_workflow", {
    "devices": ["router1", "router2"],
    "config": "vlan_configuration"
})

Best Practices

1. Workflow Design

• Start with simple, single-device workflows
• Gradually build complex multi-device workflows
• Include validation and rollback steps
• Test workflows in non-production environments first

2. Configuration Management

• Use version control for configuration templates
• Implement change approval processes
• Maintain configuration backups
• Document configuration changes

3. Security and Access Control

• Use API tokens for automation
• Implement role-based access control
• Secure credential storage
• Regular security audits

4. Monitoring and Alerting

• Monitor workflow execution status
• Set up alerts for failed workflows
• Track configuration changes
• Monitor device connectivity

5. Integration Strategy

• Start with basic device connectivity
• Add simple configuration workflows
• Integrate with existing tools gradually
• Build custom integrations as needed

Advanced Features

Template Management

# Example configuration template
template:
  name: "VLAN Configuration"
  description: "Standard VLAN configuration template"
  variables:
    - name: "vlan_id"
      type: "integer"
      required: true
    - name: "vlan_name"
      type: "string"
      required: true
    - name: "vlan_description"
      type: "string"
      default: ""

  configuration:
    cisco_ios: |
      vlan {{ vlan_id }}
        name {{ vlan_name }}
        description {{ vlan_description }}

    juniper_junos: |
      vlans {
        {{ vlan_name }} {
          vlan-id {{ vlan_id }};
          description "{{ vlan_description }}";
        }
      }

Workflow Orchestration

# Complex workflow with conditional logic
workflow:
  name: "Network Migration"
  steps:
    - name: "Pre-migration Validation"
      action: "validate_environment"
      on_failure: "abort"

    - name: "Backup Current Configuration"
      action: "backup_config"
      parallel: true

    - name: "Deploy New Configuration"
      action: "deploy_config"
      depends_on: "backup_current_configuration"
      on_failure: "rollback"

    - name: "Verify New Configuration"
      action: "verify_config"
      depends_on: "deploy_new_configuration"

    - name: "Update Documentation"
      action: "update_docs"
      depends_on: "verify_new_configuration"

Resources

• Official SlurpIT.io Documentation
• SlurpIT.io API Reference
• SlurpIT.io Blog
• Community Forum
• SlurpIT.io GitHub

For more on network automation tools, see the NetDevOps Tools Index.