Function Compute:Configure instance concurrency

Billing

The execution duration and cost of a function instance vary based on the instance concurrency. For more information, see Billing overview.

• Instance Concurrency = 1

  An instance can process only one request at a time. The billing duration starts when the first request starts to be processed and ends when the last request is processed.

  

• Instance Concurrency > 1

  An instance can process multiple requests at a time. The actual running duration of the instance is used to measure the function execution duration. The billing duration starts when the first request starts to be processed and ends when the last request is processed.

  

Concurrency throttling

By default, Function Compute supports up to 100 on-demand instances in a region. The maximum number of requests that can be concurrently processed in a region is calculated by using the following formula: 100 × Instance concurrency. For example, if you set instance concurrency to 10, a maximum of 1,000 concurrent requests can be concurrently processed in a region. If the number of concurrent requests exceeds the maximum number of requests that Function Compute can handle, the throttling error ResourceExhausted is reported.

Logging

• If instance concurrency is set to 1, Function Compute returns function logs in the X-Fc-Log-Result response header if you specify X-Fc-Log-Type: Tail in the HTTP request header when you invoke a function. If instance concurrency is set to a value greater than 1, the response header does not include function logs because the logs of a specific request cannot be obtained among concurrent requests.

• For a Node.js runtime, the function console.info() was used to return logs, which include request IDs. If Instance concurrency is set to a value greater than 1, console.info() cannot display request IDs as expected. All the request IDs are displayed as req 2. The following example shows a sample log:

  2019-11-06T14:23:37.587Z req1 [info] logger begin
  2019-11-06T14:23:37.587Z req1 [info] ctxlogger begin
  2019-11-06T14:23:37.587Z req2 [info] logger begin
  2019-11-06T14:23:37.587Z req2 [info] ctxlogger begin
  2019-11-06T14:23:40.587Z req1 [info] ctxlogger end
  2019-11-06T14:23:40.587Z req2 [info] ctxlogger end
  2019-11-06T14:23:37.587Z req2 [info] logger end
  2019-11-06T14:23:37.587Z req2 [info] logger end                    

  In this case, we recommend that you use context.logger.info() to print logs. This method allows request IDs to be displayed as expected. The following sample code shows an example:

  exports.handler = (event, context, callback) => {
      console.info('logger begin');
      context.logger.info('ctxlogger begin');
  
      setTimeout(function() {
          context.logger.info('ctxlogger end');
          console.info('logger end');
          callback(null, 'hello world');
      }, 3000);
  };                   

Error handling

When an instance concurrently processes multiple requests, unexpected process quits caused by failed requests affect other concurrent requests. Therefore, you must compile logic to capture request-level exceptions in the function code to prevent impacts on other requests. The following example shows sample code in Node.js:

exports.handler = (event, context, callback) => {
    try {
        JSON.parse(event);
    } catch (ex) {
        callback(ex);
    }

    callback(null, 'hello world');
};                    

Shared variables

When an instance concurrently processes multiple requests, errors may occur if multiple requests attempt to modify the same variable at a time. You must use mutual exclusion in your code to prevent variable modifications that are not safe for threads. The following example shows sample code in Java:

public class App implements StreamRequestHandler
{
    private static int counter = 0;

    @Override
    public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context) throws IOException {
        synchronized (this) {
            counter = counter + 1;
        }
        outputStream.write(new String("hello world").getBytes());
    }
}                    

Monitoring metrics

After you set instance concurrency to a value greater than 1, the number of used instances is reduced in the instance monitoring chart when a fixed number of requests are processed.