Function Compute:Configure instance lifecycles

Function instance lifecycle

Instances of a function are dynamically created and destroyed based on requests sent to the function. The lifecycle of each function instance includes the Creating, Invoke, and Destroy phases. The following figure shows the lifecycle of a function instance.

Creating

Function Compute creates instances based on function configurations. During this phase, Function Compute performs the following tasks in sequence:

1. Instance Create: Function Compute loads code and layers, and pulls images to create an instance.

2. Runtime Init: Function Compute initializes the runtime.

3. Init Hook: Function Compute executes the configured Initializer hook. For more information, see Initializer hooks.

The following figure shows the phases.

Invoke

Function Compute uses function handlers to process internal and external requests. Each instance that runs in a standard runtime of Function Compute executes only one request at a time. For instances that run in custom runtimes and Custom Container runtimes, each instance can process multiple requests at a time. You can use the instance concurrency feature to allow one instance to execute multiple requests at a time. For more information, see Configure instance concurrency.

Destroy

This phase is triggered if a function instance does not receive any invocations for a period of time. During this phase, Function Compute executes the PreStop hook before it destroys an instance. You can perform cleanup tasks in PreStop hooks.

Instances are destroyed in the following scenarios:

• Unoccupied instances: If an on-demand instance does not receive requests for a period of time, Function Compute automatically reclaims the instance.

• Adjustment of provisioned instance configurations: Function Compute destroys excess provisioned instances if you reduce the number of provisioned instances in the provisioned instance configuration.

• Instance exception: Function Compute destroys an instance if the instance encounters an exception during the creation or running process.

Instance freezing mechanism

Function Compute freezes an instance when no invocations are initiated for a period of time and unfreezes the instance when new requests are submitted. The following figure shows the process.

An instance is frozen in the following scenarios:

• The instance is initialized and no invocations are made yet.

• The instance is invoked to process requests and subsequent requests are not immediately submitted.

After invocations are complete, Function Compute freezes the function instances. In this case, the background processes, threads, and coroutines in the program cannot continue to run, and asynchronous logs may fail to write.

Limits

• All runtimes support the Initializer and PreStop hooks.

• The input parameter of a PreStop hook does not have the event parameter.

• The PreStop hook have no return values. The logic that is appended to the PreStop hook to return values does not take effect.

• If you use a Java runtime, you must update fc-java-core to 1.4.0 or later. Otherwise, you cannot use the PreStop hook.

• When a function returns responses, Function Compute freezes the function instance. You cannot assume that all asynchronous processes, threads, and coroutines are successfully executed when responses are returned. You cannot assume that asynchronous logs are refreshed either.

Billing

You are not charged for the number of invocations for instance lifecycle hooks. Other billable items are the same as regular invocations. The following figure shows the billable phases. For more information about billing, see Billing overview.

Prerequisites

A function is created. For more information, see Create a function.

Configure lifecycle hooks

  codeUri: './code.zip'
  ......
  instanceLifecycleConfig:
    preStop:
      handler: index.PreStop
      timeout: 60

  codeUri: './code.zip'
  ......
  instanceLifecycleConfig:
    preStop:
      handler: ""
      timeout: 60

Query hook-related logs

After you configure an instance lifecycle hook and run the code of the hook, you can query the logs of the hook.

1. Log on to the Function Compute console. In the left-side navigation pane, click Functions.

2. In the top navigation bar, select a region. On the Functions page, click the function that you want to manage.

3. On the function details page, click the Logs tab. On the Invocation Requests tab, find the request whose logs you want to view and click Advanced Logs in the Actions column.

   You can use a copied instance ID to query the start and end logs of all lifecycle hooks. You can also use the instance ID together with a hook keyword to query the start and end logs of a specified hook, such as c-62833f38-20f1629801fa4bd***** and PreStop.

   You can also query the request logs based on the request ID in the start logs and the end logs. If the user log does not contain a request ID, you can click the icon to obtain the context log.