亚马逊AWS Lambda开发全面指南

需积分: 10 83 浏览量更新于2024-07-16 收藏 5.84MB PDF 举报

“AWS Lambda开发指南，亚马逊官方文档，2018年版，涵盖了Lambda的基础教程和AWS服务的深入解析，旨在帮助开发者理解和使用AWS Lambda无服务器计算服务。” AWS Lambda是亚马逊云服务（AWS）提供的一个计算服务，它让开发者能够运行代码而无需预置或管理服务器。这个服务的核心理念是按需执行，仅在代码实际运行时才消耗资源，极大地简化了应用程序的部署和管理。 **什么是AWS Lambda？** AWS Lambda允许你上传代码（函数），然后在事件触发时自动运行这些代码。这些事件可以来自各种AWS服务，如S3对象创建、DynamoDB表更新或API Gateway请求，也可以是自定义应用程序事件。Lambda会自动处理计算资源的管理和扩展，确保你的代码能够快速响应并按需处理工作负载。 **何时使用AWS Lambda？** 你应该使用Lambda当你有以下需求： 1. **事件驱动的计算**：当需要响应特定事件时执行代码，例如处理数据、执行后台任务或实时分析。 2. **弹性和可伸缩性**：Lambda会自动扩展以应对高并发，无需手动配置或管理服务器。 3. **降低成本**：只有在代码执行时才计费，根据执行时间、内存使用量和调用次数收费，不运行时不产生费用。 **Lambda函数** Lambda函数是你的代码逻辑封装，它可以是Python、Node.js、Java、Go、C#等语言编写的。函数配置包括内存、执行时间限制和环境变量。Lambda会根据需要自动调整资源来满足函数的性能需求。 **调用类型** Lambda支持四种调用类型： 1. **同步调用**：调用者等待函数执行完成并获取结果。 2. **异步调用**：调用者立即返回，函数在后台执行，可以通过云Watch事件或SNS消息获取结果。 3. **事件源映射**：Lambda自动响应特定事件源的事件，如S3或DynamoDB。 4. **AWS API Gateway**：通过HTTP API调用触发Lambda函数。 **构建Lambda函数** 创建Lambda函数需要编写代码、创建部署包并设置函数配置。你可以直接在AWS管理控制台、CLI或使用AWS SDKs进行部署。 **监控和故障排查** Lambda提供了日志管理工具CloudWatch Logs，用于收集和查看函数的运行日志。CloudWatch Metrics则可以帮助监控函数的性能指标，如执行时间和错误率。当出现问题时，可以使用内置的故障排查工具进行诊断。 **基于AWS Lambda的应用示例** Lambda可以用于构建各种应用，如： 1. **数据处理**：处理S3上传的文件，或者从Kinesis数据流中提取信息。 2. **Web应用程序后端**：与API Gateway结合，构建无服务器的Web应用。 3. **自动化工作流**：配合Step Functions构建复杂的业务流程。 **相关话题** 除了上述内容，AWS Lambda还涉及编程模型、版本控制、别名、环境变量、函数的标记以及VPC支持等高级特性。编程模型解释了如何定义和触发函数，版本控制和别名允许管理不同版本的函数，环境变量用于存储函数运行时的配置，标记功能有助于资源组织和成本追踪，VPC支持使得Lambda函数能安全地访问VPC内的资源。 AWS Lambda为开发者提供了一个高效、灵活且经济的计算平台，用于构建和运行各种类型的应用程序和服务，同时极大地降低了基础设施管理的复杂性。

AWS Lambda Developer Guide

Programming Model

ways to end a request successfully or to notify AWS Lambda an error occurred during execution. If you

invoke the function synchronously, then AWS Lambda forwards the result back to the client.

Note

Your Lambda function code must be written in a stateless style, and have no aﬃnity with the

underlying compute infrastructure. Your code should expect local ﬁle system access, child

processes, and similar artifacts to be limited to the lifetime of the request. Persistent state

should be stored in Amazon S3, Amazon DynamoDB, or another cloud storage service.Requiring

functions to be stateless enables AWS Lambda to launch as many copies of a function as needed

to scale to the incoming rate of events and requests. These functions may not always run on the

same compute instance from request to request, and a given instance of your Lambda function

may be used more than once by AWS Lambda.

The following language speciﬁc topics provide detail information:

• Programming Model (Node.js) (p. 9)

• Programming Model for Authoring Lambda Functions in Java (p. 24)

• Programming Model for Authoring Lambda Functions in C# (p. 50)

• Programming Model for Authoring Lambda Functions in Python (p. 42)

Programming Model (Node.js)

AWS Lambda currently supports the following Node.js runtimes:

• Node.js runtime v6.10 (runtime = nodejs6.10)

• Node.js runtime v4.3 (runtime = nodejs4.3)

• Node.js runtime v0.10.42 (runtime = nodejs)

Important

Node v0.10.42 is currently marked as deprecated. You must migrate existing functions to

the newer Node.js runtime versions available on AWS Lambda (nodejs4.3 or nodejs6.10) as

soon as possible. You can request a one-time extension until June 30, 2017, by going to

the Lambda console and following the instructions provided. Failure to migrate or get

extension will result in any invocations of functions written in the Node v0.10.42 runtime

returning an invalid parameter value error. Note that you will have to follow this procedure

for each region that contains functions written in the Node v0.10.42 runtime. For information

about programming model diﬀerences in the v0.10.42 runtime, see Using the Earlier Node.js

Runtime v0.10.42 (p. 19).

When you create a Lambda function, you specify the runtime that you want to use. For more

information, see runtime parameter of CreateFunction (p. 366).

The following sections explain how common programming patterns and core concepts apply when

authoring Lambda function code in Node.js. The programming model described in the following sections

apply to both versions, except where indicated.

Topics

• Lambda Function Handler (Node.js) (p. 10)

• The Context Object (Node.js) (p. 12)

• Logging (Node.js) (p. 15)

• Function Errors (Node.js) (p. 16)

• Using the Earlier Node.js Runtime v0.10.42 (p. 19)

AWS Lambda Developer Guide

Programming Model

Lambda Function Handler (Node.js)

At the time you create a Lambda function you specify a handler, a function in your code, that AWS

Lambda can invoke when the service executes your code. Use the following general syntax when creating

a handler function in Node.js.

exports.myHandler = function(event, context,) {

...

}

The callback parameter is optional, depending on whether you want to return information to the caller.

exports.myHandler = function(event, context, callback) {

...

// Use callback() and return information to the caller.

}

In the syntax, note the following:

• event – AWS Lambda uses this parameter to pass in event data to the handler.

• context – AWS Lambda uses this parameter to provide your handler the runtime information of the

Lambda function that is executing. For more information, see The Context Object (Node.js) (p. 12).

• callback – You can use the optional callback to return information to the caller, otherwise return

value is null. For more information, see Using the Callback Parameter (p. 11).

Note

The callback is supported only in the Node.js runtimes v6.10 and v4.3. If you are using

runtime v0.10.42, you need to use the context methods (done, succeed, and fail) to properly

terminate the Lambda function. For information, see Using the Earlier Node.js Runtime

v0.10.42 (p. 19).

• myHandler – This is the name of the function AWS Lambda invokes. You export this so it is visible

to AWS Lambda. Suppose you save this code as helloworld.js. Then, helloworld.myHandler is the

handler. For more information, see handler in CreateFunction (p. 366).

• Ifyou used the RequestResponseinvocation type (synchronous execution), AWS Lambda returns

the result of the Node.js function call to the client invoking the Lambda function (in the HTTP

response to the invocation request, serialized into JSON). For example, AWS Lambda console uses

theRequestResponseinvocation type, so when you test invoke the function using the console, the

console will display the return value.

If the handler does not return anything, AWS Lambda returns null.

• Ifyou used the Eventinvocation type (asynchronous execution), the value is discarded.

Example

Consider the following Node.js example code.

exports.myHandler = function(event, context, callback) {

console.log("value1 = " + event.key1);

console.log("value2 = " + event.key2);

callback(null, "some success message");

// or

// callback("some error type");

}

AWS Lambda Developer Guide

Programming Model

This example has one function, which is also the handler. In the function, the console.log() statements

log some of the incoming event data to CloudWatch Logs. When the callback is called, the Lambda

function exits only after the Node.js event loop is empty (the Node.js event loop is not the same as the

event that was passed as a parameter).

Note

If you are using runtime v0.10.42, you need to use the context methods (done, succeed, and fail)

to properly terminate the Lambda function. For more information, see Using the Earlier Node.js

Runtime v0.10.42 (p. 19).

To upload and test this code as a Lambda function (console)

1. In the console, create a Lambda function using the following information:

• Use the hello-world blueprint.

• We recommend specifying nodejs6.10 as the runtime but you can also select nodejs4.3. The code

samples provided will work for either version.

• In Handler, replace index.handlerwith exports.myHandler.

For instructions to create a Lambda function using the console, see Step 2.1: Create a Hello World

Lambda Function (p. 189).

2. Replace the template code with the code provided in this section and create the function.

3. Test the Lambda function using the Sample event template called Hello Worldprovided in the

Lambda console. For instructions on how to do this, see Step 2.2: Invoke the Lambda Function

Manually and Verify Results, Logs, and Metrics (p. 192).

Using the Callback Parameter

The Node.js runtimes v4.3 and v6.10 support the optional callback parameter. You can use it to

explicitly return information back to the caller. The general syntax is:

callback(Error error, Object result);

Where:

• error – is an optional parameter that you can use to provide results of the failed Lambda function

execution. When a Lambda function succeeds, you can pass null as the ﬁrst parameter.

• result – is an optional parameter that you can use to provide the result of a successful function

execution. The result provided must be JSON.stringify compatible. If an error is provided, this

parameter is ignored.

Note

Using the callback parameter is optional. If you don't use the optional callback parameter, the

behavior is same as if you called the callback() without any parameters. You can specify the

callback in your code to return information to the caller.

If you don't use callback in your code, AWS Lambda will call it implicitly and the return value is null.

When the callback is called (explicitly or implicitly), AWS Lambda continues the Lambda function

invocation until the Node.js event loop is empty.

The following are example callbacks:

callback(); // Indicates success but no information returned to the caller.

callback(null); // Indicates success but no information returned to the caller.

AWS Lambda Developer Guide

Programming Model

callback(null, "success"); // Indicates success with information returned to the caller.

callback(error); // Indicates error with error information returned to the caller.

AWS Lambda treats any non-null value for the error parameter as a handled exception.

Note the following:

• Regardless of the invocation type speciﬁed at the time of the Lambda function invocation (see

Invoke (p. 401)), the callback method automatically logs the string representation of non-null values

of error to the Amazon CloudWatch Logs stream associated with the Lambda function.

• If the Lambda function was invoked synchronously (using the RequestResponse invocation type), the

callback returns a response body as follows:

• If error is null, the response body is set to the string representation of result.

• If the error is not null, the error value will be populated in the response body.

Note

When the callback(error, null) (and callback(error)) is called, Lambda will log the ﬁrst

256 KB of the error object. For a larger error object, AWS Lambda truncates the log and displays

the text Truncated by Lambda next to the error object.

The Context Object (Node.js)

While a Lambda function is executing, it can interact with AWS Lambda to get useful runtime

information such as:

• How much time is remaining before AWS Lambda terminates your Lambda function (timeout is one of

the Lambda function conﬁguration properties).

• The CloudWatch log group and log stream associated with the Lambda function that is executing.

• The AWS request ID returned to the client that invoked the Lambda function. You can use the request

ID for any follow up inquiry with AWS support.

• If the Lambda function is invoked through AWS Mobile SDK, you can learn more about the mobile

application calling the Lambda function.

AWS Lambda provides this information via the context object that the service passes as the second

parameter to your Lambda function handler. For more information, see Lambda Function Handler

(Node.js) (p. 10).

The following sections provide an example Lambda function that uses the context object, and then lists

all of the available methods and attributes.

Example

Consider the following Node.js example. The handler receives runtime information via a context

parameter.

console.log('Loading function');

exports.handler = function(event, context, callback) {

//console.log('Received event:', JSON.stringify(event, null, 2));

console.log('value1 =', event.key1);

console.log('value2 =', event.key2);

console.log('value3 =', event.key3);

console.log('remaining time =', context.getRemainingTimeInMillis());

console.log('functionName =', context.functionName);

console.log('AWSrequestID =', context.awsRequestId);

console.log('logGroupName =', context.logGroupName);

console.log('logStreamName =', context.logStreamName);

AWS Lambda Developer Guide

Programming Model

console.log('clientContext =', context.clientContext);

if (typeof context.identity !== 'undefined') {

console.log('Cognito

identity ID =', context.identity.cognitoIdentityId);

}

callback(null, event.key1); // Echo back the first key value

// or

// callback("some error type");

};

The handler code in this example logs some of the runtime information of the Lambda function to

CloudWatch. If you invoke the function using the Lambda console, the console displays the logs in the

Log output section. You can create a Lambda function using this code and test it using the console.

To test this code in the AWS Lambda console

1. In the console, create a Lambda function using the hello-world blueprint. In runtime, choose

nodejs6.10. For instructions on how to do this, see Step 2.1: Create a Hello World Lambda

Function (p. 189).

2. Test the function, and then you can also update the code to get more context information.

The Context Object Methods (Node.js)

The context object provides the following methods.

context.getRemainingTimeInMillis()

Returns the approximate remaining execution time (before timeout occurs) of the Lambda function

that is currently executing. The timeout is one of the Lambda function conﬁguration. When the timeout

reaches, AWS Lambda terminates your Lambda function.

You can use this method to check the remaining time during your function execution and take

appropriate corrective action at run time.

The general syntax is:

context.getRemainingTimeInMillis();

The Context Object Properties (Node.js)

The context object provides the following property that you can update:

callbackWaitsForEmptyEventLoop

The default value is true. This property is useful only to modify the default behavior of the callback.

By default, the callback will wait until the Node.js runtime event loop is empty before freezing the

process and returning the results to the caller. You can set this property to false to request AWS

Lambda to freeze the process soon after the callback is called, even if there are events in the event

loop. AWS Lambda will freeze the process, any state data and the events in the Node.js event loop

(any remaining events in the event loop processed when the Lambda function is called next and if

AWS Lambda chooses to use the frozen process). For more information about callback, see Using the

Callback Parameter (p. 11).

In addition, the context object provides the following properties that you can use obtain runtime

information:

剩余486页未读，继续阅读

liuyujack

粉丝: 0
资源: 1

亚马逊AWS Lambda开发全面指南

PyPI 官网下载 | cdk-lambda-extensions-0.1.232.tar.gz

Python库 | aws-cdk.aws-lambda-1.6.1.tar.gz

现有2-1.txt文件，文件目录为D:\2-1.txt，部分文件内容如图所示。要求读取2-1.txt创建Pair RDD，并对相同key值进行归约，value值进行相加，输出最终结果。

现有2-1.txt文件,文件目录为D:\2-1.txt,部分文件内容如图所示。要求读取2-1.txt创建Pair RDD,并对相同key值进行归约,value值进行相加,输出最终结果。

给一个运用detailGroup.transform(lambda x:(x.mean()-x.min())/(x.max()-x.min())).head())的例子，让我看到未处理的数据和最后的显示结果

应用detailGroup.transform(lambda x:(x.mean()-x.min())/(x.max()-x.min()))后，显示的同一列的同一组中的元素是相同的吗

解释lambda x: (x - x.mean()) / (x.std()))

System.out.println("----------entrySet+lambda----------");

最新资源