Getting Started

# Your first AI agent
resource "kubiya_agent" "assistant" {
  name        = "platform-assistant"
  runner      = kubiya_runner.main.name
  description = "Intelligent assistant for platform operations and support"
  
  # Sources are REQUIRED - every agent must have at least one
  sources = [
    kubiya_source.essential_tools.name,
    kubiya_source.infrastructure.name
  ]
  
  # Optional: Add custom instructions to guide the agent's behavior
  instructions = <<-EOT
    You are a helpful platform operations assistant. Your role is to:
    1. Help with infrastructure monitoring and troubleshooting
    2. Assist with deployment and configuration tasks
    3. Provide guidance on best practices
    4. Always explain your actions clearly and ask for confirmation on destructive operations
  EOT
  
  # Conversation starters to help users get started
  starters = [
    {
      name    = "System Status"
      command = "Check the current status of our infrastructure"
    },
    {
      name    = "Deploy Application"
      command = "Help me deploy an application to our staging environment"
    },
    {
      name    = "Troubleshoot Issue"
      command = "I'm having an issue with a service, can you help troubleshoot?"
    }
  ]
  
  # Access control - specify who can use this agent
  users  = ["devops-team@company.com", "admin@company.com"]
  groups = ["Platform Engineering", "DevOps"]
  
  # Environment variables the agent can access
  environment_variables = {
    DEFAULT_NAMESPACE = "production"
    LOG_LEVEL        = "info"
    TIMEOUT_MINUTES  = "30"
  }
}

# API credentials for external services
resource "kubiya_secret" "external_apis" {
  name        = "external-api-credentials"
  description = "API keys for third-party services"
  
  data = {
    github_token    = var.github_token
    aws_access_key  = var.aws_access_key_id
    aws_secret_key  = var.aws_secret_access_key
    slack_bot_token = var.slack_bot_token
  }
}

# Database credentials
resource "kubiya_secret" "database_creds" {
  name        = "database-credentials"
  description = "Database connection information"
  
  data = {
    db_host     = var.db_host
    db_username = var.db_username
    db_password = var.db_password
  }
}

# Enhanced agent with secrets
resource "kubiya_agent" "devops_agent" {
  name        = "devops-automation-agent"
  runner      = kubiya_runner.main.name
  description = "DevOps agent with access to external services"
  
  # Required sources
  sources = [
    kubiya_source.essential_tools.name,
    kubiya_source.infrastructure.name
  ]
  
  # Link secrets to provide secure access
  secrets = [
    kubiya_secret.external_apis.name,
    kubiya_secret.database_creds.name
  ]
  
  instructions = <<-EOT
    You are a DevOps automation agent with access to our infrastructure tools.
    You can safely interact with GitHub, AWS, and our databases.
    Always follow security best practices and confirm destructive operations.
  EOT
}

# Define variables for sensitive data
variable "github_token" {
  description = "GitHub personal access token"
  type        = string
  sensitive   = true
}

variable "aws_access_key_id" {
  description = "AWS access key ID"
  type        = string
  sensitive   = true
}

variable "aws_secret_access_key" {
  description = "AWS secret access key"
  type        = string
  sensitive   = true
}

variable "slack_bot_token" {
  description = "Slack bot token for notifications"
  type        = string
  sensitive   = true
}

# GitHub integration for repository management
resource "kubiya_integration" "github" {
  name        = "github-org"
  type        = "github"
  description = "GitHub organization integration"
  
  configuration = {
    org_name     = "your-org-name"
    api_version  = "v4"
    base_url     = "https://api.github.com"
  }
}

# Slack integration for notifications
resource "kubiya_integration" "slack" {
  name        = "company-slack"
  type        = "slack"
  description = "Company Slack workspace"
  
  configuration = {
    workspace_id = "T1234567890"
    bot_scope    = "chat:write,channels:read"
  }
}

# AWS integration for cloud resources
resource "kubiya_integration" "aws" {
  name        = "aws-production"
  type        = "aws"
  description = "Production AWS account"
  
  configuration = {
    region         = "us-west-2"
    account_alias  = "production"
  }
}

terraform {
  required_version = ">= 1.0"
  
  required_providers {
    kubiya = {
      source  = "kubiya-terraform/kubiya"
      version = "~> 1.0"
    }
  }
  
  # Use remote state for team collaboration
  backend "s3" {
    bucket = "company-terraform-state"
    key    = "kubiya/production/terraform.tfstate"
    region = "us-west-2"
  }
}

# Local values for better organization
locals {
  environment = "production"
  team        = "platform-engineering"
  
  common_labels = {
    environment = local.environment
    team        = local.team
    managed_by  = "terraform"
  }
}

# Provider configuration
provider "kubiya" {
  # API key from environment variable KUBIYA_API_KEY
}

# Primary runner for production workloads
resource "kubiya_runner" "production" {
  name        = "${local.environment}-runner"
  description = "Production runner for ${local.team}"
  type        = "vcluster"
  
  metadata = merge(local.common_labels, {
    capacity = "high"
    zone     = "us-west-2a"
  })
}

# Essential sources for all agents
resource "kubiya_source" "core_tools" {
  name        = "core-tools"
  description = "Essential tools for all production agents"
  url         = "https://github.com/kubiyabot/community-tools/tree/main/basics"
  runner      = kubiya_runner.production.name
}

resource "kubiya_source" "kubernetes_tools" {
  name        = "kubernetes-management"
  description = "Kubernetes management and troubleshooting tools"
  url         = "https://github.com/kubiyabot/community-tools/tree/main/kubernetes"
  runner      = kubiya_runner.production.name
  
  sync_schedule = "0 */6 * * *" # Sync every 6 hours
}

resource "kubiya_source" "monitoring_tools" {
  name        = "monitoring-tools"
  description = "Monitoring and observability tools"
  url         = "https://github.com/yourorg/monitoring-tools"
  branch      = "production"
  runner      = kubiya_runner.production.name
}

# Knowledge bases
resource "kubiya_knowledge" "runbooks" {
  name        = "operational-runbooks"
  description = "Step-by-step operational procedures"
  content     = file("${path.module}/knowledge/runbooks.md")
  format      = "markdown"
  
  labels = ["operations", "troubleshooting", "procedures"]
}

resource "kubiya_knowledge" "architecture_docs" {
  name        = "system-architecture"
  description = "System architecture and service dependencies"
  content     = file("${path.module}/knowledge/architecture.md")
  format      = "markdown"
  
  supported_agents = ["platform-agent", "incident-response-agent"]
}

# Secure credential management
resource "kubiya_secret" "production_credentials" {
  name        = "production-api-keys"
  description = "Production API keys and credentials"
  
  data = {
    github_token     = var.github_token
    aws_access_key   = var.aws_access_key_id
    aws_secret_key   = var.aws_secret_access_key
    datadog_api_key  = var.datadog_api_key
    pagerduty_token  = var.pagerduty_token
  }
}

# Integrations
resource "kubiya_integration" "github_org" {
  name        = "github-production"
  type        = "github"
  description = "Production GitHub organization"
  
  configuration = {
    org_name = var.github_organization
  }
}

resource "kubiya_integration" "slack_workspace" {
  name        = "company-slack"
  type        = "slack"
  description = "Company Slack workspace"
  
  configuration = {
    workspace_id = var.slack_workspace_id
  }
}

# Primary platform agent
resource "kubiya_agent" "platform_agent" {
  name        = "platform-engineering-agent"
  runner      = kubiya_runner.production.name
  description = "Primary agent for platform engineering operations"
  
  sources = [
    kubiya_source.core_tools.name,
    kubiya_source.kubernetes_tools.name,
    kubiya_source.monitoring_tools.name
  ]
  
  secrets = [
    kubiya_secret.production_credentials.name
  ]
  
  integrations = [
    kubiya_integration.github_org.name,
    kubiya_integration.slack_workspace.name
  ]
  
  instructions = <<-EOT
    You are the Platform Engineering AI Assistant for our production environment.
    
    Your primary responsibilities:
    1. Infrastructure monitoring and alerting
    2. Kubernetes cluster management and troubleshooting
    3. CI/CD pipeline support and debugging
    4. Security compliance and best practices
    5. Performance optimization recommendations
    
    Security Guidelines:
    - Always confirm destructive operations before executing
    - Follow the principle of least privilege
    - Document all significant changes
    - Escalate critical issues to on-call engineers
    
    Communication Style:
    - Be clear and concise in explanations
    - Provide step-by-step guidance for complex tasks
    - Include relevant links and documentation
    - Use appropriate technical terminology
  EOT
  
  users = [
    "platform-team@company.com",
    "devops@company.com",
    "sre-team@company.com"
  ]
  
  groups = [
    "Platform Engineering",
    "DevOps",
    "Site Reliability Engineering"
  ]
  
  starters = [
    {
      name    = "Infrastructure Status"
      command = "Provide a comprehensive status report of our infrastructure"
    },
    {
      name    = "Investigate Alert"
      command = "Help me investigate a critical alert or incident"
    },
    {
      name    = "Deploy Service"
      command = "Guide me through deploying a new service"
    },
    {
      name    = "Performance Analysis"
      command = "Analyze system performance and identify optimization opportunities"
    }
  ]
  
  environment_variables = {
    DEFAULT_NAMESPACE    = "production"
    KUBECTL_CONTEXT      = "production-cluster"
    LOG_LEVEL           = "info"
    TIMEOUT_MINUTES     = "30"
    SLACK_CHANNEL       = "#platform-engineering"
  }
}

# Incident response agent
resource "kubiya_agent" "incident_response" {
  name        = "incident-response-agent"
  runner      = kubiya_runner.production.name
  description = "Specialized agent for incident response and troubleshooting"
  
  sources = [
    kubiya_source.core_tools.name,
    kubiya_source.kubernetes_tools.name,
    kubiya_source.monitoring_tools.name
  ]
  
  secrets = [
    kubiya_secret.production_credentials.name
  ]
  
  integrations = [
    kubiya_integration.slack_workspace.name
  ]
  
  instructions = <<-EOT
    You are an Incident Response specialist focused on rapid diagnosis and resolution.
    
    During incidents:
    1. Quickly assess the scope and impact
    2. Follow established runbooks and procedures
    3. Coordinate with on-call engineers
    4. Document findings and actions taken
    5. Suggest preventive measures post-incident
    
    Always prioritize system stability and customer impact minimization.
  EOT
  
  users = ["on-call@company.com", "incident-commander@company.com"]
  groups = ["Incident Response Team", "On-Call Engineers"]
}

# Webhooks for automated responses
resource "kubiya_webhook" "critical_alerts" {
  name        = "critical-infrastructure-alerts"
  agent       = kubiya_agent.incident_response.name
  source      = "Datadog"
  
  filter = "alert.priority == 'P1' || alert.tags contains 'critical'"
  
  prompt = <<-EOT
    CRITICAL ALERT RECEIVED
    
    Alert: {{.event.alert_name}}
    Service: {{.event.host}}
    Environment: ${local.environment}
    Priority: {{.event.priority}}
    Message: {{.event.alert_message}}
    
    Immediate actions required:
    1. Assess impact and affected services
    2. Begin troubleshooting procedures
    3. Update incident channel with findings
    4. Escalate to on-call if needed
  EOT
  
  method      = "Slack"
  destination = "#incident-response"
}

# Scheduled maintenance tasks
resource "kubiya_scheduled_task" "daily_health_check" {
  name        = "production-daily-health"
  description = "Comprehensive daily health check"
  agent       = kubiya_agent.platform_agent.name
  
  schedule = "0 7 * * MON-FRI"
  
  prompt = <<-EOT
    Perform daily production health check:
    
    1. Cluster Resource Utilization
       - CPU and memory usage across nodes
       - Disk space on all volumes
       - Network performance metrics
    
    2. Application Health
       - Pod status and restart counts
       - Service availability checks
       - Database connection health
    
    3. Security and Compliance
       - Certificate expiration status
       - Security scan results
       - Access log analysis
    
    4. Performance Metrics
       - Response times and throughput
       - Error rates and patterns
       - Resource bottlenecks
    
    Generate a comprehensive report with recommendations.
  EOT
  
  notification {
    method      = "Slack"
    destination = "#daily-reports"
  }
  
  notification {
    method      = "Email"
    destination = "platform-team@company.com"
  }
}

# Outputs for reference
output "platform_agent" {
  description = "Platform engineering agent details"
  value = {
    name = kubiya_agent.platform_agent.name
    id   = kubiya_agent.platform_agent.id
  }
}

output "webhook_urls" {
  description = "Webhook URLs for external system integration"
  value = {
    critical_alerts = kubiya_webhook.critical_alerts.url
  }
  sensitive = true
}