Integrations are the foundation of Kubiya’s automation platform. They connect your existing tools and infrastructure to enable AI-powered workflows that understand your actual environment—not hypothetical examples. Platform Integration Overview

​
Why Integrations Come First

Before Kubiya can automate anything, it needs to understand your environment:
  • What tools do you use? (Kubernetes, AWS, GitHub, Slack, etc.)
  • How are they configured? (Cluster names, regions, API endpoints)
  • What are the current states? (Running services, recent deployments, active alerts)
  • How do they relate to each other? (Which services depend on which databases)
This knowledge transforms generic AI suggestions into actionable, context-aware automation.

​
How Kubiya Integrations Work

​
1. Secure Authentication

Each integration uses industry-standard authentication methods:
For services like Datadog, PagerDuty, and GitHub
integration: datadog
auth_type: api_key
credentials:
  api_key: "${DATADOG_API_KEY}"
  app_key: "${DATADOG_APP_KEY}"
Secure Credential Management

​
2. Standardized Interfaces

Kubiya abstracts away API differences between similar tools: 
# Same interface works across cloud providers
get_compute_instances(
    provider="aws",        # or "gcp", "azure"
    region="us-east-1",
    filters={"status": "running"}
)

# Unified monitoring queries
get_metrics(
    provider="datadog",    # or "newrelic", "grafana" 
    query="avg:cpu.utilization",
    timeframe="1h"
)

​
3. Real-Time Context

Integrations continuously sync with your systems to provide up-to-date information: Real-time Integration Context

​
Integration Categories

​
Cloud Platforms

AWS

EC2, EKS, RDS, Lambda, S3, CloudFormation

Google Cloud

GKE, Compute Engine, Cloud SQL, Cloud Functions

Azure

AKS, Virtual Machines, Azure SQL, Functions

​
Container Orchestration

Kubernetes

Native kubectl, Helm, operators

Docker

Container management and registries

OpenShift

Enterprise Kubernetes platform

​
CI/CD & Version Control

GitHub

Repositories, Actions, Issues, PRs

GitLab

Pipelines, merge requests, registries

Jenkins

Build automation and deployments

​
Monitoring & Observability

Datadog

Metrics, logs, traces, alerts

Grafana

Dashboards and visualization

Prometheus

Time-series metrics collection
Datadog Integration Example

​
Communication & Collaboration

Slack

Channels, messages, bot interactions

Microsoft Teams

Chat, channels, notifications

PagerDuty

Incident management and alerting

​
Infrastructure as Code

Terraform

State management and provisioning

Pulumi

Modern infrastructure as code

Ansible

Configuration management
Terraform Integration in Workflow Designer

​
Setting Up Integrations

​
Via Web Interface

  1. Navigate to Integrations in the Composer
  2. Select the tool you want to connect
  3. Configure authentication and permissions
  4. Test the connection
Integration Creation Dialog

​
Via Configuration

For automated setup, integrations can be defined as code: 
# kubiya-integrations.yaml
integrations:
  - name: prod-k8s-cluster
    type: kubernetes
    kubeconfig: /path/to/kubeconfig
    context: production
    
  - name: aws-prod
    type: aws
    region: us-west-2
    role_arn: arn:aws:iam::123456789012:role/KubiyaRole
    
  - name: github-repos
    type: github
    organization: myorg
    api_token: "${GITHUB_TOKEN}"

​
Security Model

​
Encryption Everywhere

  • Credentials encrypted at rest with AES-256
  • All API communication over TLS 1.3
  • Secrets never logged or exposed in plaintext

​
Least Privilege Access

  • Integrations granted only necessary permissions
  • Regular credential rotation supported
  • Fine-grained access controls per workflow

​
Audit & Compliance

  • Complete audit trail of all API calls
  • Integration usage tracking and reporting
  • SOC2 compliant credential handling
Security Features Overview

​
Error Handling & Reliability

Kubiya’s integration layer includes robust error handling:

​
Automatic Retries

  • Exponential backoff for transient failures
  • Circuit breaker pattern for failing services
  • Graceful degradation when services are unavailable

​
Self-Healing

  • Automatic detection of API changes
  • Dynamic adapter updates without downtime
  • Fallback mechanisms for critical operations

​
Monitoring

  • Integration health dashboard
  • Performance metrics and SLA tracking
  • Proactive alerting for integration issues
Pro Tip: Start by connecting your most critical systems first—usually your container orchestrator (Kubernetes), primary cloud provider, and main communication channel (Slack). This gives Kubiya the context it needs for the most impactful automations.

​
What’s Next?

With your integrations connected, Kubiya can begin building a context graph of your infrastructure relationships. This context enables AI agents to make intelligent decisions about automation that are specific to your environment.

Context Graph →

Learn how Kubiya maps relationships between your systems

Set Up Integrations

Step-by-step guide to connecting your tools