Architect

Kubernetes Management

AIVory Architect includes comprehensive Kubernetes management features for deploying manifests, monitoring pods, and managing clusters directly from your IDE.

  • Deploy manifests directly from the designer or editor
  • Real-time monitoring of pod status and resource usage
  • Container access via exec shell and log streaming
  • Visual pod assignment to map pods to VMs on the canvas
  • Namespace management with context switching across clusters

Requirements

Before using Kubernetes features, ensure you have the following configured:

kubectl
Installed and available in your PATH
Kubeconfig
Configured with cluster access credentials
Cluster
Running and accessible from your machine

Verify Setup

kubectl cluster-info
kubectl get nodes
Note If you see connection errors, check that your VPN is connected (if required) and that your kubeconfig file is correctly configured.

Connecting to a Cluster

Architect automatically detects clusters from:

  • Your ~/.kube/config file
  • KUBECONFIG environment variable
  • Cloud provider managed Kubernetes (EKS, AKS, GKE)

Switching Clusters

If you have multiple clusters configured:

  1. Open the context dropdown in the K8s panel
  2. Select the cluster context
  3. Architect reconnects to the new cluster
Adding a New Cluster

Add new clusters by editing kubeconfig:

# Merge a new cluster config
KUBECONFIG=~/.kube/config:new-cluster.yaml kubectl config view --flatten > merged-config
mv merged-config ~/.kube/config

Or use cloud provider CLI tools:

# AWS EKS
aws eks update-kubeconfig --name my-cluster

# Azure AKS
az aks get-credentials --resource-group myRG --name myCluster

# GCP GKE
gcloud container clusters get-credentials my-cluster --zone us-central1-a

Viewing Resources

Browse Kubernetes resources organized by:

  • By Resource Type: Pods, Deployments, Services, ConfigMaps, etc.
  • By Namespace: Resources grouped by Kubernetes namespace

Resource Tree

The Kubernetes panel shows a tree view:

├ │ │ │ │ │ │ │ │ ├ │ ─ ─ ─ ─ N ├ │ ├ │ └ N └ a ─ ─ ─ a ─ m ─ ─ ─ m ─ e e s D └ S └ P ├ ├ └ s p e ─ e ─ o ─ ─ ─ p a p ─ r ─ d ─ ─ ─ a c l v s c e o w i w w w w e : y e c e e e e : m b e b b b b d e - s - - - - m e n a s a a a o f t p e p p p n a s p r p p p i u v - - - t l ( i a d g o t 3 c b e h r / e c f i i 3 1 4 7 n ( 2 5 8 g r L 3 6 9 e o p a 🟢 🟢 🟢 l d i B c a a l s a ) n c e r )

Resource Details

Click any resource to view its details:

Resource Details Shown
Pods Status, containers, restart count, node, events
Deployments Replicas, strategy, conditions, revision history
Services Type, ports, endpoints, selectors
ConfigMaps Keys and values
Secrets Keys (values hidden until revealed)
Note Secret values are hidden by default. Click “Reveal” to view them temporarily, and they will be masked again when you navigate away.

Pod Monitoring

Status View

The pod monitoring panel shows real-time status with color-coded indicators:

Status Color Meaning
Running 🟢 Green Pod is healthy
Pending 🟡 Yellow Waiting for resources
Failed 🔴 Red Container crashed
Succeeded ⚪ Gray Job completed
Unknown ⚫ Black Cannot determine status

Real-Time Updates

Pod status updates automatically (configurable interval, default 30s).

Resource Metrics

View CPU and memory usage per pod:

  • Requires metrics-server installed in cluster
  • Shows current vs. requested resources
  • Visual indicators for over-limit usage
  • Click to see detailed resource breakdown
Note Install metrics-server with kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml to enable resource metrics.

Pod Assignment

Assign Kubernetes pods to specific VMs in your infrastructure design.

Visual Assignment

  1. Add a Server/VM to your canvas
  2. Open the Pod Assignment panel
  3. Drag pods from your manifests to the server
  4. Connections show pod-to-VM assignments

Use Cases

High-Memory VMs
Deploy databases on memory-optimized instances
GPU Instances
Run ML/AI workloads on GPU-enabled nodes
Availability Zones
Spread pods across zones for resilience
Dedicated Nodes
Isolate sensitive workloads on dedicated hardware

Container Actions

For Pods

View Logs
Stream container logs in real-time
Exec
Open interactive shell in container
Port Forward
Forward local port to container
Describe
Show full pod details and events
Delete
Remove the pod from the cluster

For Deployments

Scale
Change replica count up or down
Restart
Rolling restart all pods
View YAML
See the deployment manifest
Edit YAML
Modify and apply changes
Delete
Remove the deployment

Log Streaming

View real-time logs from containers with powerful filtering.

Viewing Logs

  1. Click a pod in the monitoring panel
  2. Select a container (if multiple)
  3. Click View Logs
  4. Logs stream in real-time

Log Controls

Control Function
Search Find text in logs (supports regex)
Filter Filter by level (info, warn, error)
Tail Lines Number of historical lines to load
Timestamps Show/hide timestamps
Pause Stop auto-scroll while still receiving
Download Save logs to file
Clear Clear the log display
Note Use regex patterns in the search field for powerful log filtering. For example, error|warn shows all errors and warnings.

Multi-Container Logs

For pods with multiple containers:

  1. Select which container’s logs to view
  2. Or choose “All Containers” for interleaved logs

Exec Into Containers

Connect to running containers for debugging.

Opening a Shell

  1. Click a pod in the monitoring panel
  2. Select a container (if multiple)
  3. Click Open Terminal or Exec
  4. Interactive shell opens in IDE terminal

Default Shell

Architect tries shells in order:

  1. /bin/bash
  2. /bin/sh
  3. Custom shell (configurable)
Warning Some minimal container images (like distroless) don’t include a shell. In these cases, exec will fail. Consider using debug containers instead.

Deploying Manifests

From the Editor

  1. Open a .yaml file containing Kubernetes manifests
  2. Right-click in the editor
  3. Select Apply to Cluster
  4. Or use Command Palette → Architect: Apply Kubernetes Manifest

From the Designer

  1. Create or import Kubernetes manifests
  2. Click Deploy to Kubernetes in the toolbar
  3. Select target namespace
  4. Review and confirm deployment

Supported Resources

Resource Status
Deployment Supported
Service Supported
ConfigMap Supported
Secret Supported
Ingress Supported
PersistentVolumeClaim Supported
StatefulSet Supported
DaemonSet Supported
Job Supported
CronJob Supported
NetworkPolicy Supported
ServiceAccount Supported

Namespace Management

Switch Namespaces

  1. Open namespace dropdown in the K8s panel
  2. Select target namespace
  3. Resources filter to selected namespace

Create Namespace

  1. Click + next to namespace dropdown
  2. Enter namespace name
  3. Click Create

View All Namespaces

Toggle “All Namespaces” to see resources across the entire cluster.

Note Viewing all namespaces may take longer to load on large clusters with many resources.

Manifest Generation

Architect can generate Kubernetes manifests from your infrastructure design.

Generate from Design

  1. Select resources on canvas
  2. Click Generate K8s Manifests
  3. Choose output format (single file or per-resource)
  4. Review and save
Example Generated Output 
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-server
  labels:
    app: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:latest
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
---
# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: web-service
spec:
  selector:
    app: web
  ports:
  - port: 80
    targetPort: 80
  type: LoadBalancer

Troubleshooting

Connection refused
  • Check kubectl can connect: kubectl cluster-info
  • Verify kubeconfig path in settings
  • Check cluster is running and accessible
  • Ensure VPN is connected if required
Permission denied
  • Check your RBAC permissions
  • Verify service account has required roles
  • Contact cluster admin for access
Pods stuck in Pending
  • Check node resources: kubectl describe nodes
  • Check pod events: kubectl describe pod <name>
  • Verify resource requests don’t exceed node capacity
  • Check for node taints that prevent scheduling
Container keeps restarting
  • Check logs: kubectl logs <pod> --previous
  • Check resource limits (OOMKilled = out of memory)
  • Verify image exists and is pullable
  • Check liveness probe configuration
Logs not streaming
  • Verify the container is running
  • Check container has stdout/stderr output
  • Try kubectl logs <pod> directly to verify

Best Practices

Resource Limits

Always set resource requests and limits:

resources:
  requests:
    memory: "128Mi"
    cpu: "100m"
  limits:
    memory: "256Mi"
    cpu: "500m"

This ensures fair scheduling and prevents runaway containers from affecting other workloads.

Health Checks

Add liveness and readiness probes:

livenessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5
Security Recommendations
  • Don’t run containers as root
  • Use read-only file systems where possible
  • Scan images for vulnerabilities
  • Use network policies to restrict traffic
  • Store secrets in Kubernetes Secrets, not ConfigMaps
Warning Never commit Kubernetes Secrets to version control. Use sealed-secrets or external secret management solutions like HashiCorp Vault.

Next Steps

Visual Designer
Design and visualize your infrastructure
Terraform Generation
Generate and deploy infrastructure as code
Docker Management
Manage containers and images
Infrastructure Management
Monitor all your resources