Membuat AI Agent untuk Monitoring Server Linux

Pendahuluan

Monitoring server tradisional sering kali terbatas pada threshold statis (misalnya: CPU > 90%). Masalahnya, threshold statis tidak menangkap konteks. CPU 80% mungkin normal untuk workload batch processing, tetapi kritis untuk layanan real-time.

Tutorial ini mengajarkan cara membangun AI Agent yang:
1. Mengumpulkan metrik sistem (CPU, RAM, Disk, Network) dan log aplikasi.
2. Menganalisis data menggunakan Large Language Model (LLM) untuk mendeteksi anomali kontekstual.
3. Memberikan rekomendasi perbaikan spesifik berdasarkan pola error.
4. Mengirim alert ke channel komunikasi (Slack/Telegram) dengan solusi yang sudah dianalisis.

Arsitektur ini mengubah monitoring dari "reaktif" menjadi "proaktif-inteligent".

Prasyarat & Persiapan

Sebelum memulai, pastikan lingkungan Anda memenuhi syarat berikut:

Hardware & Software:
- Server Linux (Ubuntu 20.04/22.04 atau Debian 11+) dengan akses root atau sudo.
- Python 3.10+ terinstall.
- Akses ke API LLM. Kami merekomendasikan menggunakan Claude Pro atau ChatGPT Plus untuk kualitas analisis log yang superior, atau Gemini Advanced untuk konteks panjang.

Paket Python:

pip install psutil openai anthropic python-dotenv requests

Struktur Proyek:

mkdir ai-server-monitor && cd ai-server-monitor
touch .env main.py config.py

Langkah Demi Langkah

Step 1: Konfigurasi Environment & API Keys

Buat file .env untuk menyimpan kredensial API. Jangan pernah hardcode API keys di kode.

# .env
OPENAI_API_KEY=sk-your-openai-key
ANTHROPIC_API_KEY=sk-ant-your-anthropic-key
SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
MONITOR_INTERVAL=300

Instal python-dotenv untuk memuat variabel ini.

Step 2: Membuat Modul Pengumpul Metrik (Data Collector)

Buat file collector.py. Modul ini bertanggung jawab untuk mengambil data sistem menggunakan psutil dan membaca log terakhir.

# collector.py
import psutil
import os
import json
from datetime import datetime

def get_system_metrics():
    """Mengambil metrik sistem saat ini."""
    metrics = {
        "timestamp": datetime.now().isoformat(),
        "cpu_percent": psutil.cpu_percent(interval=1),
        "memory_percent": psutil.virtual_memory().percent,
        "disk_usage_percent": psutil.disk_usage('/').percent,
        "load_avg": psutil.getloadavg(),
        "top_processes": []
    }

    # Ambil 5 proses dengan CPU tertinggi
    for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
        try:
            metrics["top_processes"].append({
                "pid": proc.info['pid'],
                "name": proc.info['name'],
                "cpu": proc.info['cpu_percent'],
                "mem": proc.info['memory_percent']
            })
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue

    metrics["top_processes"] = sorted(metrics["top_processes"], key=lambda x: x['cpu'], reverse=True)[:5]
    return metrics

def get_recent_logs(log_path="/var/log/syslog", lines=50):
    """Membaca baris log terakhir dari file syslog."""
    try:
        with open(log_path, 'r') as f:
            lines_list = f.readlines()
            return ''.join(lines_list[-lines:])
    except FileNotFoundError:
        return "Log file not found."
    except PermissionError:
        return "Permission denied to read log file."

Step 3: Integrasi LLM untuk Analisis Cerdas

Buat file analyzer.py. Di sini, kita menggunakan LLM untuk "memahami" data mentah. Kami akan menggunakan Claude (Anthropic) sebagai contoh karena kemampuannya yang kuat dalam reasoning teknis.

# analyzer.py
import anthropic
import os

class AIAnalyzer:
    def __init__(self):
        self.client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        self.system_prompt = """
        Kamu adalah SysOps Senior Engineer. Tugasmu menganalisis metrik sistem dan log Linux.
        1. Identifikasi anomali (bukan hanya threshold, tapi konteks).
        2. Tentukan akar masalah (root cause) berdasarkan log.
        3. Berikan rekomendasi perbaikan spesifik (perintah bash atau konfigurasi).
        4. Jika sistem sehat, kembalikan status "HEALTHY".
        Format output: JSON dengan field: status, severity, summary, root_cause, recommendations.
        """

    def analyze(self, metrics: dict, logs: str) -> dict:
        user_prompt = f"""
        Data Metrik Sistem:
        {json.dumps(metrics, indent=2)}

        Log Terakhir (50 baris):
        {logs}

        Analisis data di atas. Apakah ada masalah? Jika ya, apa solusinya?
        """

        try:
            message = self.client.messages.create(
                model="claude-3-sonnet-20240229",
                max_tokens=1024,
                system=self.system_prompt,
                messages=[{"role": "user", "content": user_prompt}]
            )
            # Parse JSON dari respons LLM
            import json
            return json.loads(message.content[0].text)
        except Exception as e:
            return {"status": "ERROR", "summary": f"LLM Analysis Failed: {str(e)}"}

Step 4: Membangun Agent Loop & Alerting

Buat file main.py yang menggabungkan semua komponen. Agent akan berjalan dalam loop, mengumpulkan data, menganalisis, dan mengirim alert jika diperlukan.

# main.py
import time
import os
import requests
import json
from collector import get_system_metrics, get_recent_logs
from analyzer import AIAnalyzer

def send_slack_alert(alert_data: dict):
    """Mengirim alert ke Slack."""
    webhook_url = os.getenv("SLACK_WEBHOOK_URL")
    if not webhook_url:
        print("Slack Webhook not configured.")
        return

    message = {
        "text": f":rotating_light: **AI Agent Alert**\n"
                f"*Status:* {alert_data.get('status', 'UNKNOWN')}\n"
                f"*Severity:* {alert_data.get('severity', 'N/A')}\n"
                f"*Summary:* {alert_data.get('summary', 'No summary')}\n"
                f"*Root Cause:* {alert_data.get('root_cause', 'Unknown')}\n"
                f"*Recommendations:*\n{alert_data.get('recommendations', 'None')}"
    }

    try:
        requests.post(webhook_url, json=message, timeout=10)
        print("Alert sent to Slack.")
    except Exception as e:
        print(f"Failed to send alert: {e}")

def run_agent():
    analyzer = AIAnalyzer()
    interval = int(os.getenv("MONITOR_INTERVAL", 300))

    print(f"AI Server Monitor started. Interval: {interval}s")

    while True:
        try:
            # 1. Kumpulkan Data
            metrics = get_system_metrics()
            logs = get_recent_logs()

            # 2. Analisis dengan AI
            analysis = analyzer.analyze(metrics, logs)

            # 3. Tindakan
            if analysis.get("status") != "HEALTHY":
                print(f"ANOMALY DETECTED: {analysis.get('summary')}")
                send_slack_alert(analysis)
            else:
                print(f"System Healthy. CPU: {metrics['cpu_percent']}%, Mem: {metrics['memory_percent']}%")

        except Exception as e:
            print(f"Error in agent loop: {e}")

        time.sleep(interval)

if __name__ == "__main__":
    run_agent()

Step 5: Menjalankan Agent

Jalankan agent di terminal. Untuk testing, ubah MONITOR_INTERVAL di .env menjadi 10 (10 detik) agar cepat melihat hasil.

python main.py

Jika ada anomali (misalnya Anda menjalankan stress command di server), agent akan mendeteksinya, menganalisis log, dan mengirim pesan ke Slack dengan rekomendasi seperti: "Proses 'stress' memakan 95% CPU. Rekomendasi: kill -9 <PID> atau batasi resource dengan cgroups."

Tips Optimasi & Keamanan

1. Rate Limiting LLM: Jangan panggil LLM setiap detik. Interval 5-15 menit sudah cukup untuk monitoring kesehatan umum. Untuk deteksi real-time, gunakan threshold sederhana dulu, baru panggil LLM jika threshold terlewati (Hybrid Approach).
2. Masking Data Sensitif: Sebelum mengirim log ke LLM, pastikan data sensitif (password, API keys) di-mask. Gunakan regex sederhana di collector.py sebelum mengirim ke analyzer.py.
3. Caching Hasil Analisis: Jika metrik tidak berubah signifikan dari siklus sebelumnya, cache hasil analisis untuk menghemat biaya API.
4. Keamanan API Key: Gunakan environment variables atau secret manager (AWS Secrets Manager, HashiCorp Vault). Jangan commit file .env ke Git.

Troubleshooting Error Umum

Error: PermissionError saat membaca log
- Solusi: Jalankan script sebagai user dengan akses baca ke /var/log/syslog. Atau, ubah path log ke file aplikasi yang memiliki permission lebih longgar.

Error: JSONDecodeError dari LLM
- Solusi: LLM kadang menambahkan markdown (json) di sekitar output. Tambahkan parser yang lebih robust di `analyzer.py`:python
import re
text = message.content[0].text
match = re.search(r'{.*}', text, re.DOTALL)
if match:
return json.loads(match.group())
```

Error: Connection Timeout ke Slack
- Solusi: Pastikan firewall server mengizinkan outbound traffic ke port 443. Tambahkan retry logic dengan tenacity library.

Kesimpulan

Anda telah berhasil membangun AI Agent yang mampu memantau server Linux secara otonom. Berbeda dengan monitoring tradisional, agent ini memahami konteks log dan metrik, memberikan diagnosis akar masalah, dan merekomendasikan solusi spesifik.

Untuk pengembangan lebih lanjut, Anda dapat:
- Mengintegrasikan dengan Prometheus/Grafana untuk visualisasi.
- Menambahkan aksi otomatis (auto-healing) seperti restart service jika error terdeteksi (dengan konfirmasi manual).
- Menggunakan Perplexity Pro untuk riset solusi error yang jarang terjadi secara real-time.

Dengan arsitektur ini, tim DevOps Anda dapat fokus pada perbaikan infrastruktur, bukan sekadar membaca alert yang tidak jelas.