AWS Lambda结合Android应用的初次尝试

Android - 从零开始的AWS Lambda

和传统的应用程序不同，用Lambda函数，结合其他微服务框架一起使用，可以把一个原本很复杂、冗余的应用分解成一个个小的部分。每个框架之间只需要专注于做自己的事情，相互之间是松耦合的。这增加了开发程序的可能性、灵活性。

但是，要从头自己开始学习还是有点点困难的。所以这次记录了一下从头开始学习Lambda函+Cognito与Android配合使用的过程。

“AWS Lambda 是一项计算服务，可使您无需预配置或管理服务器即可运行代码。”
所以,我们只需要关注于代码本身，由AWS Lambda 管理提供内存、CPU、网络和其他资源均衡的计算机群。

实现了啥

​ 创建一个简单的 Android 移动应用程序，通过在本地应用程序中输入字符串并提交，从 Amazon Cognito 身份池检索 AWS 凭证，并使用包含请求数据的事件，调用 Lambda 函数处理请求，记录Cloud Watch日志并向前端返回响应，返回字符串。

​ 如果这些字连在一起就看不懂了：其实就是输入两个字符串，提交之后触发了Lambda函数；触发成功，返回toast，由Lambda函数记录调用的日志。

STEP - 1 创建AWS IAM用户并授予管理员权限

AWS建议 不要使用 AWS 账户根用户执行任务，而是应为需要管理员访问权限的每个人创建新的 IAM 用户。

所以，拥有IAM用户是访问AWS服务的先决条件。

想要通过控制台创建用户，可以下载AWS CLI。

1. 进入[AWS IAM console - 用户 - 添加用户]

2. 添加用户

a. 用户名即之后用于访问服务的用户名

b. 因为之后要通过CLI访问，所以务必要选择编程访问。选择AWS控制台访问的话，之后可以通过 IAM 控制台控制面板中找到账户的登录 URL进行登录。

https://account-ID-or-alias.signin.aws.amazon.com/console

3. 创建组

筛选策略中，选择AdministratorAccess，即赋予组用户管理员权限。

4. （可选）输入可跟踪用户信息的键值对

本次实验暂时用不到。接下来的步骤确认信息无误后，拥有管理员权限的IAM用户即可生成。

5. 返回[AWS IAM console - 用户]

查看创建好的用户，记录用户ARN，用于之后身份验证服务。arn是AWS资源的唯一标识。

6. 选择[安全证书 - 创建访问密钥]

把密钥下载下来，之后登录AWS CLI需要用。

STEP - 2 创建AWS IAM执行角色

要让AWS Lambda对我们的资源进行访问、操作，以实现具体功能，就要授予其相对应的权限。

IAM 角色就是信任的实体授予权限的安全方法。实体可以是其他账户的IAM用户、AWS的服务、EC2上的程序代码等。

1. 打开[AWS IAM console - 用户 - 角色]

选择创建角色，使用案例选择Lambda。

2. 确保当前角色拥有CloudWatch Logs日志写入的权限

这里选择AWSLambdaBasicExecutionRole。

3. 角色名称键入lambda-android-role

这样，拥有basic权限的角色就配置好了。

STEP - 3 创建函数

接下来的操作会用到shell，编写一个简单的触发器，在本地打包创建成lambda函数并提交。

• PS也可以选择在AWS Lambda的网页端中，通过现成的模板或创作设置想要的函数。 也支持在本地写完Lambda函数，打包之后上传。

  

在这里，我选择用WSL 2（Windows Subsystem for Linux 2) 进行脚本编写创建，如果使用Linux/MacOS直接调用默认shell就可以了。

其实后来我看开发指南，Windows自带的Power Shell也是可以的，被我弄复杂了；但是Power Shell长得丑，算了不亏。
方法有很多，只要是shell能编写程序就OK。

1. 创建index.js文件

Lambda支持很多语言，如：javascript, java, python, c# … 这里按照官方给的教程，我用的是node.js，很简洁。

• 函数第一个参数event是来自调用程序（即我们的APP上的操作）信息对象。
• 第二个参数contexts是包含有关调用、函数和执行环境的对象，这里将会获取日志流的名称，然后将其返回到调用方。
• 第三个参数callback 是一个回调函数，可以用它对调用程序（APP）进行响应（response）。

这里我们简单定义了，调用程序中的函数，在console中记录事件并返回给客户端一个字符串的操作。

exports.handler = function(event, context, callback) {
   console.log("Received event: ", event);
   var data = {
       "greetings": "Hello, " + event.firstName + " " + event.lastName + "."
   };
   callback(null, data);
}

2. 打包文件

把文件打包成压缩包，并下载aws命令行。

zip function.zip index.js

sudo apt install awscli

如果是第一次使用AWS CLI，那么就要设置用户。

aws config

按照指令，输入STEP - 1中下载好[用户]-[安全证书]中的key，以及服务的地域等信息。

3. 使用 create-function 命令创建 Lambda 函数

• handler的名字之所以叫index.handler是因为这是index.js文件中的handler函数。（好像是这样的）
• lambda role arn可以直接在AWS CLI中查看，也可以在IAM role中查看。
• 这里创建的函数名称叫AndroidBackendLambdaFunction。

aws lambda create-function --function-name [lambda函数名] \ --zip-file 
fileb://[目录路径]/function.zip --handler index.handler --runtime nodejs12.x \
--role [lambda role arn]

同时，可以在AWS Lambda网页端查看到函数了。

STEP - 4 创建Amazon Cognito 身份池

Amazon Cognito 提供用户池和身份池。

用户池是为应用程序提供注册和登录选项的用户目录，身份池提供 AWS 凭证以向用户授予对其他 AWS 服务的访问权限。

这里用身份池，并授予其执行Lambda AndroidBackendLambdaFunction 函数的权限。

1. 打开 Amazon Cognito 控制台

2. 新建身份池

身份池名为 JavaFunctionAndroidEventHandlerPool ，并弃用未经验证的访问权限（即允许游客登录应用程序，触发该函数）。

在未经身份验证（unauthenticated identities）的角色中，输入

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "mobileanalytics:PutEvents",
            "cognito-sync:*"
         ],
         "Resource":[
            "*"
         ]
      },
      {
         "Effect":"Allow",
         "Action":[
            "lambda:invokefunction"
         ],
         "Resource":[
            "arn:aws:lambda:us-east-1:[account-id]:function:AndroidBackendLambdaFunction"
         ]
      }
   ]
}

Resource对应的就是AndroidBackendLambdaFunction的arn。[account-id]即IAM用户的id。

创建成功后,系统会提示保存身份池id等信息,记录下来,下一步将会用到.

STEP - 5 创建Android程序

做了这么多，终于可以开始创建应用了，其实应用在这个demo里面就显得比较简单。

值得注意的是，Lambda函数最好在API 28以上运行。在新建APP的时候，注意API版本。

如果在创建工程之后，同步（sync）失败，（可能报app compact xxx29.+之类的错），有以下几种解决方法:

1. 检查project structure - Android SDK版本和build.gradle(module: app)中的sdk版本是否不一致.
2. 检查project structure -Update,是否版本过低. 建议升级较新的Android Studio版本. 我就是因为版本比较旧,所以不能用29的包.

1. 创建一个Hello World工程

• 创建的工程名为AndroidEventGenerator

• 在 build.gradle (Module:app) 文件的 dependencies 部分中添加以下内容

    implementation 'com.amazonaws:aws-android-sdk-core:2.2.+'
    implementation 'com.amazonaws:aws-android-sdk-lambda:2.2.+'
    implementation "commons-logging:commons-logging:1.2"

• 在 AndroidManifest.xml中，添加连接 Internet的权限

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.androideventgenerator">
	...
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
manifest>

2. 写代码

• 为了Lambda函数能够正确响应，创建和之前index.js中实现相同方法、参数的RequestClass和ResponseClass

package com.example.androideventgenerator;

public class RequestClass {
    String firstName;
    String lastName;

    public RequestClass(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public RequestClass() {
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

package com.example.androideventgenerator;

public class ResponseClass {
    String greetings;

    public ResponseClass(String greetings) {
        this.greetings = greetings;
    }

    public ResponseClass() {
    }

    public String getGreetings() {
        return greetings;
    }

    public void setGreetings(String greetings) {
        this.greetings = greetings;
    }
}

• MyInterface

  用annotation@LambdaFunction对接口函数进行映射，注意这个映射的函数名应该一致，参数是request。

package com.example.androideventgenerator;

import com.amazonaws.mobileconnectors.lambdainvoker.LambdaFunction;

public interface MyInterface {
    /**
     * Invoke the Lambda function "AndroidBackendLambdaFunction".
     * The function name is the method name.
     */
    @LambdaFunction
    ResponseClass AndroidBackendLambdaFunction(RequestClass request);

}

• MainActivity

  代码要注意的地方我写在注释里。。好长啊

package com.example.androideventgenerator;

import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

import com.amazonaws.auth.CognitoCachingCredentialsProvider;
import com.amazonaws.mobileconnectors.lambdainvoker.LambdaFunctionException;
import com.amazonaws.mobileconnectors.lambdainvoker.LambdaInvokerFactory;
import com.amazonaws.regions.Regions;

import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    EditText editText1, editText2;
    Button button;
    RequestClass request;
    MyInterface myInterface;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 创建提供Cognito服务的对象实例，这句在创建身份池的时候AWS已经提供了
        CognitoCachingCredentialsProvider cognitoProvider = new CognitoCachingCredentialsProvider(
       //把XXXXXXXXX改成创建的身份池id
                this.getApplicationContext(), "us-east-1:XXXXXXXXX", Regions.US_EAST_1);
        
        // 创建调用Lambda函数的工厂代理对象
        //第三个参数是 a AWS credentials provider
        LambdaInvokerFactory factory = new LambdaInvokerFactory(this.getApplicationContext(),
                Regions.US_EAST_1, cognitoProvider);
		//用工厂和默认的binder（第二个参数）创建一个Lambda对象实例
        myInterface = factory.build(MyInterface.class);
        editText1 = findViewById(R.id.editText);
        editText2 = findViewById(R.id.editText2);
        button = findViewById(R.id.button);
        
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String firstName = editText1.getText().toString();
                String LastName = editText2.getText().toString();
                request = new RequestClass(firstName, LastName);
                // The Lambda function invocation results in a network call.
                // Make sure it is not called from the main thread.
                //执行一个异步的请求
                new myAsyncTask().execute(request);
            }
        });


    }
	//为了防止内存泄漏，不要把AsyncTask放在主线程中
    class myAsyncTask extends AsyncTask<RequestClass, Void, ResponseClass> {

        @Override
        protected ResponseClass doInBackground(RequestClass... params) {
            // invoke "echo" method. In case it fails, it will throw a
            // LambdaFunctionException.
            try {
                //******调用Lambda函数，返回request********//
                return myInterface.AndroidBackendLambdaFunction(params[0]);
            } catch (LambdaFunctionException lfe) {
                Log.e("Tag", "Failed to invoke echo", lfe);
                return null;
            }
        }

        @Override
        protected void onPostExecute(ResponseClass result) {
            if (result == null) {
                return;
            }
            /* 执行完onBackgoundTask方法后，执行onPostExecute方法 ！
            ** 如果onBackgoundTask return回来的结果不为空，即Lambda函数调用成功的话！
            ** 就do a toast ！
            */
            Toast.makeText(MainActivity.this, result.getGreetings(), Toast.LENGTH_LONG).show();
        }
    }
}

3. 结果

虽然我的布局有点丑，但是可以看出，点击SUBMIT之后，输入的字符串在应用内被响应了。

同时，在AWS CloudWatch或AWS Lambda监控的CloudWatch中，都可以查看到Lambda函数记录的日志内容。

补充：调用函数的收费时间等信息也是可以看到的。
可以看出，我们只写了Lambda功能代码，没有部署过物理资源，而实际调用物理资源的时间也微乎其微。

参考: AWS Lambda 开发人员指南