# Trusted Compute Overview

Trusted Compute (TC) is an advanced security framework that combines software-defined security extensions with underlying hardware security capabilities to create isolated execution environments for edge computing workloads. This technology provides a hardware root of trust that ensures sensitive applications and data remain protected from external threats, unauthorized access, and potential system compromises.

## What is Trusted Compute?

Trusted Compute leverages Intel platform security features to create hardware-assisted virtual machines where applications can execute in complete isolation from other workloads. This isolation extends beyond traditional containerization by providing:

- **Hardware-backed Security**: Utilizes Intel platform security features like Intel VT-x (Virtualization Technology) and TPM (Trusted Platform Module)
- **Memory Encryption**: Provides runtime protection for sensitive algorithms and detection models by safeguarding against cold boot attacks and physical threats to the memory subsystem
- **Secure Boot Process**: Ensures only authenticated and verified code executes within the trusted environment
- **Full Disk Encryption (FDE) Process**: Prevents unauthorized access to disk data, particularly in scenarios involving device theft, loss, or physical compromise

## Key Benefits

### Enhanced Security
- **Workload Isolation**: Applications run in completely isolated environments, preventing cross-contamination
- **Data Protection**: Sensitive runtime data remains protected from other workloads
- **Runtime Security**: Guards against runtime attacks, malware, and unauthorized modifications

### Edge Computing Optimization
- **Reduced Attack Surface**: Minimizes exposure points for potential security breaches
- **Local Processing**: Enables secure processing of sensitive data at the edge without cloud dependencies
- **Performance**: Maintains high performance while providing security through hardware acceleration

## Use Cases

Trusted Compute is particularly valuable for:

- **AI/ML Model Protection**: Securing proprietary algorithms and training data
- **Video Analytics**: Processing sensitive surveillance or traffic data securely
- **Autonomous AI Agents**: Protecting decision-making processes and sensitive operational data in self-governing AI systems

## Enabling Trusted Compute in Your Application

Existing containerised applications can be deployed under Trusted Compute without any modification to the application code or container image. The changes required depend on whether you are using Kubernetes or Docker directly.

### Kubernetes

Add the following field to your Pod or Deployment manifest to instruct the scheduler to use the Kata Containers runtime:

```yaml
runtimeClassName: kata-qemu
```

This single addition places the container inside a hardware-assisted virtual machine, providing the full Trusted Compute isolation boundary with no further configuration needed.

### Docker

When running containers directly with Docker (via containerd), specify the Kata runtime using the `--runtime` flag:

```bash
docker run --runtime io.containerd.kata.v2 <image>
```

Alternatively, set it in the container's `hostConfig` when using the Docker API or Compose:

```yaml
runtime: io.containerd.kata.v2
```

### Resource Requirements

Optionally, if the application does not already define resource requests and limits, it is recommended to add them. Inside a Trusted Compute environment the container runs within a dedicated VM, so explicitly declaring resources guarantees that the required CPU and memory are reserved and available for the application:

```yaml
resources:
  requests:
    memory: "<app-required-memory>"   # e.g. "12Gi" — minimum memory needed by the application
    cpu: "<app-required-cpu>"         # e.g. "4"    — minimum CPU cores needed by the application
  limits:
    memory: "<app-max-memory>"        # e.g. "16Gi" — maximum memory the application may consume
    cpu: "<app-max-cpu>"              # e.g. "6"    — maximum CPU cores the application may consume
```

Replace the placeholder values with the actual resource requirements of your application. Without these declarations the Kubernetes scheduler may place the Pod on a node that cannot satisfy the application's runtime needs. Setting `requests` ensures the resources are reserved at scheduling time, while `limits` caps the maximum consumption within the TC environment.

## Reference Implementation

This documentation includes a practical example demonstrating Trusted Compute implementation:

- **[Smart Intersection Deployment](./trusted_compute_si.md)**: A comprehensive guide showing how to deploy video analytics applications using Trusted Compute technology, including step-by-step instructions for isolating AI models and processing pipelines in a secure execution environment.

- **[Smart Traffic Intersection Agent Deployment](./trusted_compute_si_agent.md)**: A comprehensive guide showing how to deploy Agentic AI applications using Trusted Compute technology, including step-by-step instructions for isolating AI & VLM models and processing pipelines in a secure execution environment.