Sandbox Deep Hibernation (file system only recovery)

Overview

Prerequisites

File system only recovery is an extension of Sandbox Deep Hibernation. Before you use this feature, meet the following prerequisites:

1. Meet all Deep Hibernation prerequisites: This includes applying for the allowlist, configuring session affinity and session isolation, using a custom image, and running on a CPU instance. For details, see Sandbox Deep Hibernation (Pause and Resume Session).

2. Additional allowlist application: This feature requires separate enablement. submit a ticket to request access to the "Sandbox Deep Hibernation - file system only recovery" capability.

Limitations and constraints

In addition to the general limitations described in Sandbox Deep Hibernation (Pause and Resume Session), file system only recovery has the following additional constraints:

• With file system only recovery, in-memory data is not restored. Any data cached in memory before the pause, such as variables, objects, or connection pools, will be lost.

• After recovery, the instance starts with a fresh process. Your application must be able to initialize itself, for example, by starting a service through the container's ENTRYPOINT.

• We recommend designing your application to be restartable. This means the process can be fully initialized through the container image's ENTRYPOINT, and the data in the file system can be used directly after the process starts.

Procedure

PUT /2023-03-30/functions/{functionName}/sessions/{sessionId}/resume?fileSystemOnly=true

func resumeSessionFileSystemOnly(client *fc.Client, functionName, sessionId *string) (*fc.ResumeSessionResponse, error) {
    return client.ResumeSessionWithOptions(
        functionName,
        sessionId,
        &fc.ResumeSessionRequest{
            FileSystemOnly: tea.Bool(true),
        },
        nil,
        &dara.RuntimeOptions{},
    )
}

// Example usage
func main() {
    client, err := createClient()
    if err != nil {
        panic(err)
    }

    functionName := tea.String("my-sandbox-function")
    sessionId := tea.String("my-session-id")

    resp, err := resumeSessionFileSystemOnly(client, functionName, sessionId)
    if err != nil {
        fmt.Printf("ResumeSession (file system only recovery) failed: %v\n", err)
        return
    }
    fmt.Printf("ResumeSession succeeded. Session status: %s\n", tea.StringValue(resp.Body.SessionStatus))
}

func resumeSession(client *fc.Client, functionName, sessionId *string) (*fc.ResumeSessionResponse, error) {
    return client.ResumeSessionWithOptions(
        functionName,
        sessionId,
        &fc.ResumeSessionRequest{},
        nil,
        &dara.RuntimeOptions{},
    )
}

End-to-end workflow

The following example shows the complete workflow for using file system only recovery:

1. Create a function: Enable session affinity and session isolation, and select a custom image.

2. Create a session: Call CreateSession or InvokeFunction to create a session.

3. Use the Sandbox: Install dependencies, download models, or generate intermediate files.

4. Pause the session: Call PauseSession to save a snapshot and destroy the instance. You do not incur charges for CPU and memory while the session is paused.

5. Restore only the file system: Call ResumeSession and set fileSystemOnly=true.

6. Verify the recovery: Call GetSession to confirm that the session status is Active. Then, call InvokeFunction to verify that the file system data is intact.

7. Continue use: The file system is identical to its pre-pause state, but the process is newly started. To pause again, repeat steps 4 through 6.

8. Delete the session: When finished, call DeleteSession to release resources.

Complete Go SDK example

package main

import (
    "fmt"
    "os"

    openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
    fc "github.com/alibabacloud-go/fc-20230330/client"
    "github.com/alibabacloud-go/tea/dara"
    "github.com/alibabacloud-go/tea/tea"
)

func main() {
    // 1. Initialize the client.
    client, err := fc.NewClient(&openapi.Config{
        RegionId:        tea.String("cn-shanghai"),
        AccessKeyId:     tea.String(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")),
        AccessKeySecret: tea.String(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")),
        Endpoint:        tea.String("<Account ID>.cn-shanghai.fc.aliyuncs.com"),
    })
    if err != nil {
        panic(err)
    }

    functionName := tea.String("my-sandbox-function")
    headerKey := "x-session-id"

    // 2. Invoke the function for the first time to automatically create a session.
    invokeResp, err := client.InvokeFunctionWithOptions(
        functionName,
        &fc.InvokeFunctionRequest{},
        &fc.InvokeFunctionHeaders{},
        &dara.RuntimeOptions{},
    )
    if err != nil {
        panic(err)
    }
    sessionId := invokeResp.Headers[headerKey]
    fmt.Printf("Session created. Session ID: %s\n", tea.StringValue(sessionId))

    // 3. Perform operations in the Sandbox (install dependencies, generate files, etc.).
    _, err = client.InvokeFunctionWithOptions(
        functionName,
        &fc.InvokeFunctionRequest{},
        &fc.InvokeFunctionHeaders{
            CommonHeaders: map[string]*string{
                headerKey: sessionId,
            },
        },
        &dara.RuntimeOptions{},
    )
    if err != nil {
        panic(err)
    }
    fmt.Println("Sandbox operations completed (dependencies installed, files generated, etc.).")

    // 4. Pause the session (save a snapshot and destroy the instance).
    pauseResp, err := client.PauseSessionWithOptions(
        functionName,
        sessionId,
        &fc.PauseSessionRequest{},
        nil,
        &dara.RuntimeOptions{},
    )
    if err != nil {
        panic(err)
    }
    fmt.Printf("PauseSession succeeded. Status: %s\n", tea.StringValue(pauseResp.Body.SessionStatus))

    // 5. Restore only the file system.
    resumeResp, err := client.ResumeSessionWithOptions(
        functionName,
        sessionId,
        &fc.ResumeSessionRequest{
            FileSystemOnly: tea.Bool(true),
        },
        nil,
        &dara.RuntimeOptions{},
    )
    if err != nil {
        panic(err)
    }
    fmt.Printf("ResumeSession (file system only recovery) succeeded. Status: %s\n", tea.StringValue(resumeResp.Body.SessionStatus))

    // 6. Continue using the Sandbox (the file system is restored, and the process is newly started).
    _, err = client.InvokeFunctionWithOptions(
        functionName,
        &fc.InvokeFunctionRequest{},
        &fc.InvokeFunctionHeaders{
            CommonHeaders: map[string]*string{
                headerKey: sessionId,
            },
        },
        &dara.RuntimeOptions{},
    )
    if err != nil {
        panic(err)
    }
    fmt.Println("Function invocation after recovery succeeded. The file system data matches the pre-pause state.")

    // 7. Delete the session when finished.
    _, err = client.DeleteSessionWithOptions(
        functionName,
        sessionId,
        &fc.DeleteSessionRequest{},
        nil,
        &dara.RuntimeOptions{},
    )
    if err != nil {
        panic(err)
    }
    fmt.Println("Session deleted.")
}

FAQ

Related documents

• Sandbox Deep Hibernation (Pause and Resume Session)

• ResumeSession - Resume session API documentation

• PauseSession - Pause session API documentation

• Session introduction

• Session lifecycle management

• HeaderField affinity configuration

• General limits and principles of session affinity