AWS Service [Deprecated]

Overview

Amazon Web Services (AWS) provides an extensive collection of cloud-based services. Atlas App Services provides a generic AWS service that enables you to connect to many of these services.

Configuration Parameters

You will need to provide values for the following parameters when you create an AWS service interface:

{
  "name": "<Service Name>",
  "type": "aws",
  "config": {
    "accessKeyId": <Access Key ID>,
    "region": "us-east-1"
  },
  "secret_config": {
    "secretAccessKey": "<Secret Name>"
  }
}

Service Actions

Each AWS service has different actions that you can perform on that service. App Services uses the action names specified in the AWS SDK for Go for each service.

For each supported AWS service, App Services supports any action that:

1. Takes a single input parameter.

2. Returns one of two objects: an output object, or an error.

For example, the S3 service includes a PutObject action. App Services supports this action because it takes a single input type of PutObjectInput, and returns either a PutObjectOutput or an error.

AWS Service Rules

You must specify rules to enable the AWS services and actions. Each rule applies to a single service API, plus one or all actions on that service. As with other service rules in App Services, a rule must evaluate to true to enable the action.

For example, the following rule enables all actions on the Kinesis service:

click to enlarge

This rule can also be expressed as the following rule expression. Note that in the array of actions, the asterisk (*) after the service name indicates that all actions of that service are enabled:

{
   "name": "kinesis",
   "actions": [
      "kinesis:*"
   ]
}

Rule Conditions

For each service action, the rule you create may include any of the properties of the input object for that action as a condition for validating the rule. The %%args expansion provides access to these properties.

Example

S3 PutObject

The S3 service includes the PutObject action, which takes an input object of type of PutObjectInput. You can reference any of the properties on the PutObjectInput object in a rule's When expression with the %%args expansion.

Using the Bucket property of the PutObjectInput object, you can create a rule that enables the PutObject action on the S3 service, but restricts the action to a list of approved buckets. In this example, we use a user-defined constant called myS3Buckets for the list of approved bucket names:

click to enlarge

This can also be expressed as the following JSON:

{
   "name": "s3",
   "actions": [
      "s3:PutObject"
   ],
   "when": {
      "%%args.Bucket": {
            "$in": "%%values.myS3Buckets"
      }
   }
}

S3 GetObject

The S3 service includes the GetObject action, which takes an input object of type of GetObjectInput. You can reference any of the properties on the GetObjectInput object in a rule's When expression with the %%args expansion.

In the following example, we create a rule that enables the GetObject action on a specific bucket called realmReadWritableBucket:

click to enlarge

This can also be expressed as the following JSON:

{
   "name": "s3",
   "actions": [
      "s3:GetObject"
   ],
   "when": {
      "%%args.Bucket": {
            "$in": "realmReadWritableBucket"
      }
   }
}

Usage

You can call an AWS service from an Atlas Function and from the SDKs. The following sections show each of these processes.

exports = async function() {
  const s3 = context.services.get('MyAwsService').s3("us-east-1");
  const result = await s3.PutObject({
    "Bucket": "my-bucket",
    "Key": "example",
    "Body": "hello there"
  });
  console.log(EJSON.stringify(result));
  return result;
};

exports = async function(arg) {
   const s3 = context.services.get('MyAwsService').s3("us-east-1");
   const result = await s3.GetObject({
      "Bucket": "realmReadWritableBucket",
      "Key": "coffee.jpeg"
   });
   console.log(EJSON.stringify(result));
   return result;
};

exports = function(){
  const s3 = context.services.get("MyAwsService").s3("us-east-1");
  const presignedUrl = s3.PresignURL({
   "Bucket": "my-s3-bucket-name",
   "Key": "/some/path",
   // HTTP method that is valid for this signed URL. Can use PUT for uploads, or GET for downloads.
   "Method": "GET",
   // Duration of the lifetime of the signed url, in milliseconds
   "ExpirationMS": 30000,
  })
  return presignedUrl
};

exports = async function(event) {
  const kinesis = context.services.get('MyAwsService').kinesis("us-east-1");
  const result = await kinesis.PutRecord({
    Data: JSON.stringify(event.fullDocument),
    StreamName: "realmStream",
    PartitionKey: "1"
  });
  console.log(EJSON.stringify(result));
  return result;
};

exports = async function() {
  const lambda = context.services.get('MyAwsService').lambda("us-east-1");
  const result = await lambda.Invoke({
    FunctionName: "myLambdaFunction",
    Payload: context.user.id
  });
  console.log(result.Payload.text());
  return EJSON.parse(result.Payload.text());
};

exports = async function(){
  const ses = context.services.get('MyAwsService').ses("us-east-1");
  const result = await ses.SendEmail({
    Source: "sender@example.com",
    Destination: { ToAddresses: ["docs@mongodb.com"] },
    Message: {
      Body: {
        Html: {
          Charset: "UTF-8",
          Data: `This is a message from user ${context.user.id}`
        }
      },
      Subject: {
        Charset: "UTF-8",
        Data: "Test Email Please Ignore"
      }
    }
  });
  console.log(EJSON.stringify(result));
  return result;
};

Supported AWS Services

Your App can connect to the following AWS services:

• Athena

• Batch

• CloudWatch

• Comprehend

• EC2

• Firehose

• Glacier

• IOT

• Kinesis

• Lambda

• Lex Runtime Service

• Machine Learning

• Mobile Analytics

• Polly

• RDS

• Redshift

• Rekognition

• S3

• SES

• Step Functions (SFN)

• SNS

• SQS

• Textract