Introduction
While AWS Lambda, a highly popular serverless computing service, does not officially provide a Dart runtime, you can deploy functions created in Dart to AWS Lambda using the custom runtime mechanism.
Deploying Dart functions to AWS Lambda enables you to utilize them not only within AWS Lambda but also integrate them with services like Amazon API Gateway, allowing you to leverage them in Flutter applications as well. This unified codebase in Dart offers great convenience.
In this article, we will briefly introduce how to deploy Dart functions to AWS Lambda.
Preparation
In this article, we will use Serverless Framework and Docker Desktop to deploy Dart functions to AWS Lambda. If you haven't installed them yet, please complete the installation using the following commands or links.
Additionally, you'll need an AWS account and access tokens for AWS services.
AWS Account
AWS Authentication Token
Once you have generated the authentication token, set it in the environment variables as follows:
export AWS_ACCESS_KEY_ID=xxxxxxxxxx
export AWS_SECRET_ACCESS_KEY=xxxxxxxxxx
Serverless Framework
brew install serverless
Docker Desktop
https://www.docker.com/products/docker-desktop/
Implementation and Registration of Functions
Now let's implement the Dart function to deploy it to AWS Lambda.
Project Structure
We'll proceed with the following structure. Details about Dockerfile
and serverless.yml
will be explained later.
.
├── Dockerfile
├── LICENSE
├── analysis_options.yaml
├── lib
│ ├── functions.dart
│ └── main.dart
├── pubspec.lock
├── pubspec.yaml
└── serverless.yml
Installing Packages
When deploying to AWS Lambda, you'll need to use the Dart custom runtime aws_lambda_dart_runtime_ns. Please add it to your dependencies in pubspec.yaml
using the following command or manually:
https://pub.dev/packages/aws_lambda_dart_runtime_ns
dart pub add aws_lambda_dart_runtime_ns
dart pub get
name: sample
environment:
sdk: ^3.3.4
dependencies:
aws_lambda_dart_runtime_ns: ^0.0.13
dev_dependencies:
lints: ^3.0.0
test: ^1.24.0
Creating a Function to Deploy to AWS Lambda
Let's create a simple function to deploy to AWS Lambda.
For now, let's make the function simply return the string Hello, World!
when called.
import 'package:aws_lambda_dart_runtime_ns/aws_lambda_dart_runtime_ns.dart';
FunctionHandler get sayHelloWorld {
return FunctionHandler(
name: 'hello-world',
action: (context, event) {
// Perform various operations here such as
// file IO, database operations, etc.
return InvocationResult(
requestId: context.requestId,
body: {
'message': 'Hello, World!',
},
);
},
);
}
To briefly explain, the FunctionHandler
object represents the function executed on AWS Lambda.
The name
of FunctionHandler
is the required name when the function (or command) is invoked.
Additionally, this name must be associated with the command definition in serverless.yml
, which will be introduced later.
The action
of FunctionHandler
defines the actual behavior of the function (or command). In this example, it simply returns the message 'Hello, World!'
, but you can perform various operations such as file operations or DB operations within action
.
The InvocationResult
needed to be returned in action
represents the result of the processing. You can set any JSON data in the body
of InvocationResult
.
Registering the Created Function to the Custom Runtime
Let's register the sayHelloWorld
function we created earlier to the custom runtime. It's very simple.
import 'package:aws_lambda_dart_runtime_ns/aws_lambda_dart_runtime_ns.dart';
import 'package:sample/functions.dart' as fn;
Future<void> main(List<String> args) async {
await invokeAwsLambdaRuntime([
fn.sayHelloWorld, // This is what you need to do
]);
}
When registering the created function to the custom runtime, all you need to do is call the invokeAwsLambdaRuntime
function and pass the functions you want to register as arguments.
With this, the process of creating the function you want to register with AWS Lambda and registering it with the custom runtime is complete.
Deploying to AWS Lambda
Once you've reached this point, all that's left is to deploy the program you've created to AWS Lambda.
We'll define the Dockerfile
and serverless.yml
as follows:
I'm not very knowledgeable about hardware, but it seems that using ARM-based AWS Graviton makes you happy, so we'll proceed with an architecture based on arm64.
Dockerfile
FROM arm64v8/dart:latest as build-image
WORKDIR /work
COPY ./ ./
RUN dart pub get
RUN dart compile exe ./lib/main.dart -o ./bootstrap
RUN chmod +x bootstrap
FROM --platform=linux/arm64 public.ecr.aws/lambda/provided:latest
COPY --from=build-image /work/bootstrap /var/runtime/
CMD ["dummyHandler"]
If the folder structure where the Dart program is located is different, please modify the ./lib/main.dart
part accordingly.
serverless.yml
service: sample-app
provider:
name: aws
runtime: provided
timeout: 30
region: ap-northeast-1
architecture: arm64
ecr:
images:
appImage:
path: ./
platform: linux/arm64
functions:
hello-world:
image:
name: appImage
command:
- hello-world
Since there is no specific preference for the region, let's use ap-northeast-1 (Tokyo)
for now.
When defining functions
, please pay attention to ensuring that the name of the command
matches the name
defined earlier for FunctionHandler
.
Deployment
Once you have configured everything, you can deploy the function you created to AWS Lambda using the following Serverless Framework command:
Please make sure Docker Desktop is running before executing the command.
sls deploy
sls deploy
Running "serverless" from node_modules
(node:6460) [DEP0040] DeprecationWarning: The `punycode` module is deprecated. Please use a userland alternative instead.
(Use `node --trace-deprecation ...` to show where the warning was created)
Deploying sample-app to stage dev (ap-northeast-1)
✔ Service deployed to stack sample-app-dev (32s)
functions:
hello-world: sample-app-dev-hello-world
References
The project created in this article is publicly available in the following repository. If you'd like to quickly try it out, feel free to clone or fork it and deploy it to AWS Lambda to play around with.
https://github.com/myConsciousness/sample-aws-lambda-with-dart-runtime
Top comments (0)