PaperlayerView exact revision on arXiv

Source-linked AI summary

Reducio: Optimized Confidential Serverless Cloud Deployments for Enterprise Customers

Vikram Ramaswamy, Chuqi Zhang, Adil Ahmad

arXiv:2608.30171v1cs.CR

TL;DR

Serverless functions expose sensitive data to cloud providers, while CVM-based confidential platforms introduce deployment and memory overheads. Reducio addresses these constraints with intra-kernel isolation and predictive, layer-wise snapshot caching, reducing memory use while maintaining comparable startup performance.

  • Problem

    Confidential CVM-based serverless platforms face privacy-preserving deployment challenges, including infrastructure changes, large platform memory requirements, and cold-start latency.

  • Method

    Reducio combines an intra-kernel security monitor for function isolation inside CVMs with layer-wise partial snapshot caching guided by invocation patterns and memory availability.

  • Results

    64% less memory on average is used than prior work while retaining 19.3% of geometric-mean function performance, with comparable secure-CoW startup latency.

  • Takeaways & Limitations

    Reducio provides a deployment-friendly confidential serverless design that co-optimizes platform memory use and function latency.

  • Takeaways & Limitations

    Prior intra-kernel isolation approaches may require complex cloud-infrastructure modifications, limiting deployment applicability in the target model.

Abstract

from arXiv · show

Serverless platforms based on Confidential Virtual Machines (CVMs) have been recently proposed to address the privacy problems with serverless functions, while achieving low latency. Unfortunately, our study indicates that to achieve these properties, existing proposals impose non-trivial requirements in terms of infrastructure changes and platform memory. Reducio is an alternate serverless platform design that does not require infrastructure changes and significantly reduces platform memory requirements. The platform is designed using two key components: (1) a function isolation framework inside a CVM based on kernel deprivileging features that minimize infrastructure requirements, and (2) a layer-wise caching methodology and algorithm that effectively uses a small in-memory function cache. Our evaluation indicates that Reducio can significantly reduce both platform requirements for deployment and function memory consumption.

I. INTRODUCTION

Reducio targets privacy-preserving serverless computing by combining deployment-friendly function isolation inside CVMs with memory-efficient, predictive layered caching. Its evaluation reports comparable startup latency to prior work and substantially lower cache memory use.

  • Motivation: Serverless functions create privacy risks because providers manage execution and can access sensitive information supplied to those functions.Examples include patient data used for analytics.
  • Limitations of Prior Work: Existing confidential serverless platforms face deployment, memory, and latency gaps, including infrastructure changes, large in-memory Zygotes, and poor LRU eviction latency.Twenty-one Zygotes require ≃5.15GiB of memory in the reported benchmark evaluation.
  • Reducio Design: Reducio uses an intra-kernel security monitor inside a CVM to isolate functions while minimizing infrastructure changes.The monitor is based on intra-kernel privilege isolation principles and is designed for self-contained deployment within CVMs.
  • Reducio Design: Reducio retains partial function snapshots across stack layers and uses learned invocation patterns plus memory availability to guide caching decisions.Its predictive algorithm retains or pre-warms snapshots to reduce latency and evicts them to preserve memory.
  • Implementation: Reducio adds monitor checks during fork and page-fault handling to validate secure Copy-on-Write operations needed for fast function startup.These checks validate kernel intentions during privileged memory-management operations.
  • Evaluation: Reducio’s secure-CoW function startup latency is comparable to prior work, indicating that its deployment-friendly monitor maintains high performance.The evaluation also examined security properties related to correct CoW forks and preventing sensitive-information leakage through container sharing.
  • Evaluation: 64% less memory on average is used by Reducio’s partial and predictive caching than prior work, while retaining 19.3% of geometric-mean function performance.The prototype was evaluated on security, performance, and memory use using micro-benchmarks and real-world Azure function traces.

II. SYSTEM AND DEPLOYMENT MODEL

The deployment model targets enterprise customers running high-volume serverless workloads on sensitive data. CVMs provide hardware-based isolation and remote attestation, while CVM boot and measurement costs make per-invocation deployment impractical.

  • Enterprise Requirements: Enterprise customers may invoke hundreds of thousands of functions per hour and require secure, high-performance, cost-effective processing of sensitive data.The motivating examples include healthcare and financial data supplied by downstream customers.
  • Real-World Examples: Serverless workloads from companies such as LiveWell and Booz Allen illustrate enterprise use of cloud serverless computing for sensitive or demanding applications.LiveWell analyzes health habits and biometrics for over 150,000 daily users.
  • Confidential Virtual Machines: Confidential serverless computing uses hardware-assisted trusted execution environments, with CVMs offering a foundation for isolating serverless functions.CVMs protect the guest software stack from outside components such as the host hypervisor and co-located virtual machines.
  • Remote Attestation: CVMs support remote attestation by producing signed measurements that remote verifiers use to confirm authenticity and integrity before provisioning secrets.CVM custom data can also support authenticated key exchange for secure channel establishment.

IV. MOTIVATION

Existing CVM-based confidential serverless designs trade deployment practicality, startup latency, and memory efficiency against function isolation and attestation. Reducio targets these limitations with container-based deployment and mechanisms for faster, more memory-conscious execution.

  • Deployment and latency limitations: Booting a fresh CVM for each invocation incurs costly cold starts because guest components must be loaded and integrity-measured.The cold-start cost can dominate execution time for short-lived functions.
  • Existing isolation approaches: Existing approaches use trusted microkernels, CVM partitioning, or intra-kernel isolation to isolate function containers.CoFunc uses a trusted microkernel, Wallet and Veil use CVM partitioning, and Erebor embeds a monitor inside the CVM kernel.
  • Deployment and latency limitations: These designs can require host-side, hypervisor, paravisor, or platform-specific changes that hinder portability and practical deployment.Wallet and CoFunc impose infrastructure modifications, while CoFunc shifts core operating-system services to the host hypervisor.
  • Memory and warm-start limitations: In-memory Zygotes reduce startup work through measured Copy-on-Write launches, but their snapshots consume considerable memory.Zygotes capture initialized runtimes, dependencies, and code state so functions can launch without loading and measuring everything from scratch.
  • Deployment and latency limitations: Erebor lacks runtime validation for fork and therefore incurs 4.6s average function boot latency in the reported experiments.The missing validation prevents the secure fork support needed for low-latency function startup.
  • Memory and warm-start limitations: A naive on-demand cache retains functions until timeout and consumes around 2.8× more memory during execution than the optimized algorithm.Eviction is necessary under low utilization or high memory pressure, a persistent issue in traditional serverless platforms.

V. THREAT MODEL

REDUCIO assumes an untrusted host OS and hypervisor, while requiring isolated CPU-only function execution for enterprise workloads. It excludes several attack classes, including side channels, hardware defects, denial-of-service, and physical attacks.

  • The host OS and hypervisor are untrusted and may use CVM-host interfaces or malicious workloads to infer or leak sensitive function data.The model considers attacks through I/O and networking, as well as attempts to access co-located functions.
  • Each function must run in an isolated environment because enterprise clients may process different downstream customers’ data.Developers are trusted and provide function code, dependencies, and integrity measurements.
  • REDUCIO assumes functions run solely on CPUs because CVM support for external accelerators remains an ongoing research area.
  • The threat model excludes micro-architectural side channels, hardware defects, denial-of-service, and physical attacks.Hardware is assumed patched to the latest version for the considered hardware defects.

VI. REDUCIO DESIGN

REDUCIO combines intra-kernel isolation with partial, pattern-directed snapshot caching to improve deployment practicality and co-optimize memory use and startup latency. Its design targets prior requirements for CVM partitioning, host-hypervisor I/O delegation, and large in-memory snapshots.

  • REDUCIO is presented as a confidential serverless solution for enterprise customers that addresses platform adaptation and memory-latency co-optimization.
  • REDUCIO uses an intra-kernel security monitor to isolate each serverless function inside a CVM without requiring CVM partitioning or host-hypervisor I/O delegation.Functions execute in Trusted Processes containing a LibOS, with runtime and manifest integrity measured for attestation.
  • The system’s key contributions are organized around deployment-friendly isolation and selective snapshot management rather than infrastructure redesign.The contribution list explicitly frames the design around these two approaches.
  • The design extends intra-kernel isolation with secure CoW fork validation, supporting efficient function caching and fast startup.The paper identifies secure CoW fork as essential for maintaining these properties.
  • Partial caching selectively retains, evicts, or pre-warms function snapshots according to invocation patterns and available memory.This approach targets cold-start latency while reducing the number of in-memory Zygotes.

A. Intra-Kernel Monitor Extensions for Fork Validation

REDUCIO instruments Linux fork and page-fault paths and adds monitor calls to validate secure CoW fork invariants. The monitor tracks protected-page ownership, mappings, copying, and process relationships throughout fork execution.

  • Intra-Kernel Monitor Extensions for Fork Validation: REDUCIO adds security monitor calls and kernel instrumentation during fork and page faults to uphold secure CoW fork invariants.These extensions support efficient function caching and fast startup.
  • Intra-Kernel Monitor Extensions for Fork Validation: Protected memory regions remain inaccessible to untrusted components, and only processes authorized by REDUCIO-MONITOR may access them.Trusted-process address spaces consist solely of protected physical pages.
  • Intra-Kernel Monitor Extensions for Fork Validation: Table III summarizes sensitive privileged instructions and marks pre-existing SMCs that were updated with new invariants.
  • Intra-Kernel Monitor Extensions for Fork Validation: Fork validation requires family relationships, identical virtual addresses, explicit CoW declarations, and equal protected-page counts across related processes.
  • Intra-Kernel Monitor Extensions for Fork Validation: The fork sequence initializes the child relationship, declares page tables, marks eligible pages CoW, and finalizes only after monitor checks complete.The monitor validates page-table declarations, CoW mappings, and parent-child protected-page consistency.
  • Intra-Kernel Monitor Extensions for Fork Validation: Page-fault handling declares new protected pages, checks ownership, copies only between related protected pages, and updates mappings with validation.The protected_copy operation also preserves the old page’s virtual-address attribute for the new page.

B. Layered Predictive Function Process Caching

Reducio caches function execution state in layered, partially warmed processes and uses secure forks to serve requests from the lowest-latency available layer. Predictive retention and eviction balance startup latency against platform memory.

  • Cache design: Reducio partially caches pre-warmed trusted processes using a library OS and secure forks rather than the file system.The approach is driven by incoming-function invocation patterns and system configurations.
  • Cache layers: The Bare, Runtime, and Warm layers progressively load the LibOS, language runtime, and function dependencies, respectively.Warm instances can load user data and directly execute the function, while Bare instances can be warmed for any requested function.
  • Cache layers: Warm-layer loading has the smallest delay, while lower layers add process creation, library loading, and measurement overheads.Allowed CoW sharing differs by layer and affects memory usage.
  • Predictive management: A predictive time-series algorithm models function arrivals with Poisson distributions to retain or pre-warm likely-needed snapshots and evict them when demand falls.Retention also uses inter-arrival time and a provider-configured cost function incorporating startup latency and memory footprint.
  • Request serving: The coordinator forks from Warm →Runtime →Bare according to startup latency and warms successive layers after serving from a lower layer.This maintains pre-warmed function and language instances for future requests.

VII. IMPLEMENTATION

The Reducio prototype extends a Linux kernel and Gramine LibOS for Intel TDX-based CVMs, adding monitor, forking, coordination, and OpenWhisk integration components.

  • VII. IMPLEMENTATION: Reducio was prototyped for Linux kernels running on Intel TDX-based CVMs and includes an intra-kernel monitor, partial-caching-aware LibOS, and function cache coordinator.The coordinator integrates with OpenWhisk.
  • VII. IMPLEMENTATION: The implementation added 1205 lines to Gramine LibOS for layered forking and implemented the coordinator in 1700 lines of Python.The coordinator handles invocation requests through a flash server setup.

VIII. SECURITY ANALYSIS

Reducio’s security design protects secure CoW forks and shared partially warmed states through monitor-enforced invariants, isolation, measurements, and restrictions on post-user-data forking.

  • VIII. SECURITY ANALYSIS: Monitor invariants protect parent–child page-table mappings and page contents during secure CoW forks.Shared mappings are restricted to related processes, matching virtual addresses, and nonwrite permissions.
  • VIII. SECURITY ANALYSIS: The deprivileged kernel cannot directly access protected pages, and the monitor limits copying to read-only CoW pages between pre-declared protected pages.These restrictions are enforced for related processes.
  • VIII. SECURITY ANALYSIS: Bare and Runtime states contain no function- or user-specific information because they are created before user data is processed.Each invocation runs in a freshly forked trusted process, while User-state processes cannot fork after handling inputs.
  • VIII. SECURITY ANALYSIS: Hash-based measurement, monitor verification, and memory isolation protect shared Bare, Runtime, and Warm states from substituted components.Hash verification failure causes the LibOS to abort during shared-state creation.

IX. PERFORMANCE EVALUATION

The evaluation uses a controlled Intel Xeon and Intel TDX environment and compares Reducio with on-demand and always-cached confidential-forking baselines.

  • IX. PERFORMANCE EVALUATION: Experiments ran on an Intel Xeon 6510P server with 32 physical CPU cores, 128GiB memory, and 512GB SSD storage.The guest CVM received 8 vCPU cores, 24GiB memory, and 100GB virtualized storage.
  • IX. PERFORMANCE EVALUATION: The guest CVM used Ubuntu 24.04 with Intel TDX module version 1.5.05.46 and Linux 6.6 inside the CVM.The host ran Ubuntu 24.04 and Linux v6.8.0.
  • IX. PERFORMANCE EVALUATION: Baseline-OD uses confidential forking but loads functions only when invoked, whereas Baseline-FC uses the same configuration with an always-continuously populated cache.Reducio is the partial-caching configuration under evaluation.

B. Micro-Benchmarks

REDUCIO’s layered states trade memory footprint against startup latency, while secure fork and predictive caching support confidential serverless execution. End-to-end results show reasonable geometric-mean latency relative to baselines, but substantially worse p99 latency and higher per-function averages.

  • Secure CoW fork: 3.48× and 5.84× overheads occur for fork+execve and pagefault benchmarks compared with Native.The overhead is attributed to numerous Secure Monitor Calls for paging.
  • Startup latency: Warm starts are often 10–20× faster than Bare and Runtime, with reductions up to 25× for functions having larger dependency trees.Warm restores a nearly execution-ready process snapshot and bypasses dependency loading.
  • Memory usage: Bare uses ∼2MB, Runtime ∼9MB, and Warm ranges from 25MB to over 700MB depending on application complexity.The states retain progressively more runtime, application, and dependency information.
  • Serverless workloads: REDUCIO’s p99 latency is 8385 ms, versus 3307 ms for Baseline-OD and 2687 ms for Baseline-FC.The higher tail latency reflects more cold starts than the comparison systems, while cache management keeps geometric-mean performance relatively close.
  • Serverless workloads: Function-balanced geometric means of per-function average end-to-end latency are 1208 ms for REDUCIO, 738 ms for Baseline-OD, and 500 ms for Baseline-FC.Sparse invocations perform worst with predictive caching, while bursty functions benefit most.

X. RELATED WORK

REDUCIO builds on intra-kernel isolation rather than trusted-hypervisor designs, extending that approach with secure fork across layered function-caching states. Its design is deployment-friendly and targets the memory–latency trade-off.

  • Privileged software monitoring: Trusted-hypervisor process-isolation designs are unsuitable for confidential cloud computing because the cloud hypervisor is untrusted.REDUCIO instead aligns with intra-kernel isolation approaches.
  • Privileged software monitoring: Intra-kernel systems virtualize a higher-privileged monitor within the kernel using hardware memory protection and privileged-instruction trapping.These mechanisms create a minimal trusted execution layer.
  • REDUCIO: REDUCIO extends intra-kernel isolation with secure fork over layered function-caching states and combines it with intelligent predictive caching.The resulting platform is designed to optimize the memory–latency trade-off while remaining deployment-friendly.
Loading 2608.30171v1…