Link Search Menu Expand Document Documentation Menu
Documentation

Scheduling reports with AWS Lambda

Use AWS Lambda to run the Reporting CLI in response to a trigger, such as a schedule. The Lambda function runs the Reporting CLI from a container image, so the OpenSearch Dashboards URL that you report on must be reachable from the Lambda function.

The container image installs Google Chrome dependencies that are available only for the x86-64 architecture. To build the image, you need Docker. On a computer with a different architecture, such as a Mac with Apple silicon, build the image using the --platform linux/amd64 option.

Prerequisites

To use the Reporting CLI with AWS Lambda, you need to do the following preliminary steps.

Step 1: Create a container image with a Dockerfile

You need to assemble the container image by running a Dockerfile. When you run the Dockerfile, it downloads the OpenSearch artifact required to use the Reporting CLI. To learn more about Dockerfiles, see Dockerfile reference.

Copy the following sample configurations into a Dockerfile:

# Define function directory
ARG FUNCTION_DIR="/function"

# Base image of the docker container
FROM node:lts-slim AS build-image

# Include global arg in this stage of the build
ARG FUNCTION_DIR

# AWS Lambda runtime dependencies
RUN apt-get update && \
    apt-get install -y \
        g++ \
        make \
        unzip \
        libcurl4-openssl-dev \
        autoconf \
        automake \
        libtool \
        cmake \
        python3 \
        libkrb5-dev \
        curl

# Copy function code
WORKDIR ${FUNCTION_DIR}
RUN npm install @opensearch-project/reporting-cli && npm install aws-lambda-ric

# Build Stage 2: Copy Build Stage 1 files in to Stage 2. Install chrome, then remove chrome to keep the dependencies.
FROM node:lts-slim
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Set working directory to function root directory
WORKDIR ${FUNCTION_DIR}
# Copy in the build image dependencies
COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}

# Install latest chrome dev package and fonts to support major char sets (Chinese, Japanese, Arabic, Hebrew, Thai and a few others)
# Note: this installs the necessary libs to make the bundled version of Chromium that Puppeteer installs, work.
RUN apt-get update \
    && apt-get install -y wget gnupg \
    && wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - \
    && sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list' \
    && apt-get update \
    && apt-get install -y google-chrome-stable fonts-ipafont-gothic fonts-wqy-zenhei fonts-thai-tlwg fonts-kacst fonts-freefont-ttf libxss1 \
      --no-install-recommends \
    && apt-get remove -y google-chrome-stable \
    && rm -rf /var/lib/apt/lists/*

ENTRYPOINT ["/usr/local/bin/npx", "aws-lambda-ric"]

ENV HOME="/tmp"
CMD [ "/function/node_modules/@opensearch-project/reporting-cli/src/index.handler" ]

Next, run the following build command within the same directory that contains the Dockerfile:

docker build --platform linux/amd64 -t opensearch-reporting-cli .

Step 2: Create a private repository with Amazon ECR

You need to follow the instructions to create an image repository, see Getting started with Amazon ECR using the AWS Management Console.

Give your repository the name opensearch-reporting-cli.

In addition to the Amazon ECR instructions, you need to make several adjustments for the Reporting CLI to function properly as described in the following steps in this procedure.

Step 3: Push the image to the private repository

You need to get several commands from the AWS ECR Console to run within the Dockerfile directory.

  1. After you create your repository, select it from Private repositories.
  2. Choose view push commands.
  3. Copy and run each command shown in Push commands for opensearch-reporting-cli sequentially in the Dockerfile directory.

For more details about Docker push commands, see Pushing a Docker image in the Amazon ECR user guide.

Step 4: Create a Lambda function with the container image

Now that you have a container image created for the Reporting CLI, you need to create a function defined as the container image.

  1. Open the AWS Lambda console and choose Functions.
  2. Choose Create function, then choose Container image and fill in a name for the function.
  3. In Container image URI, choose Browse images and select opensearch-reporting-cli for the image repository.
  4. In Images select the image, and choose Select image.
  5. In Architecture, choose x86_64.
  6. Choose Create function.
  7. Go to Lambda > functions and choose the function you created.
  8. Choose Configuration > General configuration > Edit timeout and set the timeout in Lambda to 5 minutes to allow the Reporting CLI to generate the report.
  9. Change the Ephemeral storage setting to at least 1024 MB. The default setting is not a sufficient storage amount to support report generation.
  10. Test the function by providing values either in a JSON test event or as Lambda environment variables.

To provide values that are the same for every run, such as the email addresses, set the corresponding environment variables, such as OPENSEARCH_FROM and OPENSEARCH_TO, in the Lambda function configuration. To provide values in the test event or trigger payload, use the long option names without the leading dashes as JSON keys, for example, url, format, transport, from, and to. For the credentials key, specify the value in the <username>:<password> format. For a list of options and environment variables, see Reporting CLI options.

The following example event specifies the URL, the email transport, the sender and recipient email addresses, and the email subject:

{
  "url": "https://playground.opensearch.org/app/dashboards#/view/084aed50-6f48-11ed-a3d5-1ddbf0afc873",
  "transport": "ses",
  "from": "sender@example.com",
  "to": "recipient@example.com",
  "subject": "Test lambda docker image"
}

The Lambda function saves the report in the /tmp directory of the function, so specify an email transport to receive the report.

To learn more about AWS Lambda functions, see Deploying Lambda functions as container images in the AWS Lambda documentation.

Step 5: Add the trigger to start the AWS Lambda function

Set the trigger that starts the report. AWS Lambda can use other AWS services as triggers, such as Amazon Simple Notification Service (Amazon SNS), Amazon S3, or Amazon EventBridge.

  1. In the Triggers section, choose Add trigger.
  2. Select a trigger from the list. To generate reports on a schedule, use an Amazon EventBridge schedule. For more information, see Invoke a Lambda function on a schedule in the AWS Lambda documentation.
  3. Choose Test to initiate the function.

(Optional) Step 6: Add the role permission for Amazon SES

If you want to use Amazon SES for the email transport, you need to set up permissions.

  1. Select Configuration and choose Execution role.
  2. In Summary, choose Permissions.
  3. Select {}JSON to open the JSON policy editor.
  4. Add the permissions for the Amazon SES resource that you want to use.

The following example provides the resource ARN for the send email action:

{
"Effect": "Allow",
"Action": [
      "ses:SendEmail",
      "ses:SendRawEmail"
            ],
"Resource": "arn:aws:ses:us-west-2:555555511111:identity/sender@example.com"
}

To learn more about setting role permissions, see Permissions in the AWS Lambda user guide.

350 characters left

Have a question? .

Want to contribute? or .