Tutorials

What You'll Learn:

• Planning your SysManage deployment
• Installing and configuring the server
• Setting up your first 5 agents
• Organizing hosts with tags and groups
• Configuring basic monitoring and alerts

Step-by-Step:

1. Environment Planning: Define your infrastructure requirements
2. Server Setup: Install SysManage server with SSL certificates
3. Agent Deployment: Install agents on target hosts
4. Organization: Create meaningful tags and host groups
5. Monitoring: Set up basic health monitoring
6. Testing: Verify all components are working

What You'll Learn:

• Creating Ansible inventory for SysManage
• Writing deployment playbooks
• Handling different operating systems
• Automated agent approval processes
• Verification and troubleshooting

---
- name: Deploy SysManage Agents
  hosts: all
  become: yes
  vars:
    sysmanage_server: "sysmanage.company.com"

  tasks:
    - name: Install agent package
      package:
        name: sysmanage-agent
        state: present

    - name: Configure agent
      template:
        src: sysmanage-agent.yaml.j2
        dest: /etc/sysmanage-agent/sysmanage-agent.yaml
      notify: restart agent

    - name: Start agent service
      service:
        name: sysmanage-agent
        state: started
        enabled: yes

Pipeline Stages:

1. Detection: Automatic security update detection
2. Staging: Apply updates to staging environment
3. Testing: Automated testing and validation
4. Approval: Manual approval for production
5. Production: Phased rollout to production hosts
6. Monitoring: Post-update health monitoring

#!/usr/bin/env python3
import requests
import json
import time

class SysManageUpdater:
    def __init__(self, base_url, token):
        self.base_url = base_url
        self.headers = {"Authorization": f"Bearer {token}"}

    def get_security_updates(self, environment):
        """Get available security updates for environment"""
        response = requests.get(
            f"{self.base_url}/api/updates/security",
            headers=self.headers,
            params={"tags": environment}
        )
        return response.json()

    def apply_updates(self, host_ids, update_type="security"):
        """Apply updates to specified hosts"""
        payload = {
            "host_ids": host_ids,
            "update_type": update_type,
            "schedule": "immediate"
        }
        response = requests.post(
            f"{self.base_url}/api/updates/apply",
            headers=self.headers,
            json=payload
        )
        return response.json()

    def monitor_update_progress(self, task_id):
        """Monitor update progress"""
        while True:
            response = requests.get(
                f"{self.base_url}/api/tasks/{task_id}",
                headers=self.headers
            )
            task = response.json()
            if task["status"] in ["completed", "failed"]:
                return task
            time.sleep(30)

Standardization Approach:

• Create package mapping between platforms
• Define standard software stacks
• Implement consistent naming conventions
• Handle platform-specific configurations
• Automate cross-platform deployments

Monitoring Components:

• System Metrics: CPU, memory, disk, network monitoring
• Application Health: Service status and performance
• Security Monitoring: Failed logins, security events
• Capacity Planning: Growth trends and forecasting

# Alert configuration example
alerts:
  - name: "High CPU Usage"
    condition: "cpu_usage > 85"
    duration: "5m"
    severity: "warning"
    notifications:
      - email: "ops@company.com"
      - webhook: "https://hooks.slack.com/..."

  - name: "Host Offline"
    condition: "host_status == 'offline'"
    duration: "2m"
    severity: "critical"
    notifications:
      - email: "oncall@company.com"
      - sms: "+1234567890"

  - name: "Security Updates Available"
    condition: "security_updates > 0"
    duration: "1h"
    severity: "info"
    notifications:
      - email: "security@company.com"

Automation Examples:

• Automated host provisioning workflows
• Custom reporting and analytics
• Integration with CI/CD pipelines
• Webhook-based event handling
• External system integrations

#!/bin/bash
# Automated host provisioning with SysManage

HOST_IP="$1"
HOST_ROLE="$2"
ENVIRONMENT="$3"

# Install and configure agent
curl -sSL https://install.sysmanage.com/agent.sh | bash -s -- \
    --server "https://sysmanage.company.com" \
    --tags "$HOST_ROLE,$ENVIRONMENT" \
    --auto-approve

# Wait for agent registration
echo "Waiting for host registration..."
while ! curl -s -H "Authorization: Bearer $API_TOKEN" \
    "https://sysmanage.company.com/api/hosts?ip=$HOST_IP" | grep -q "$HOST_IP"; do
    sleep 5
done

# Apply role-specific package set
curl -X POST -H "Authorization: Bearer $API_TOKEN" \
    -H "Content-Type: application/json" \
    "https://sysmanage.company.com/api/packages/install" \
    -d "{\"hosts\": [\"$HOST_IP\"], \"packages\": $(cat roles/$HOST_ROLE/packages.json)}"

echo "Host $HOST_IP provisioned successfully"

Security Areas:

• Certificate Management: Automated certificate rotation
• User Access Control: Role-based permissions
• Network Security: Firewall and network policies
• Audit Logging: Comprehensive activity tracking
• Vulnerability Management: Regular security scanning

Integration Steps:

1. Configure LDAP connection settings
2. Map LDAP groups to SysManage roles
3. Set up user attribute mapping
4. Configure single sign-on (SSO)
5. Test authentication and authorization
6. Implement fallback authentication