Explore serverless computing with AWS Lambda, deploy ML pipelines, and manage applications efficiently without infrastructure worries.

Serverless 101 - Essential Patterns for Data Scientist.png

codes.tar.gz

AWS_ACCESS_KEY_ID

AWS_SECRET_ACCESS_KEY

AWS_REGION

AWS_OUTPUT

AWS_BUCKET_NAME

SERVERLESS_ORG

SERVERLESS_APP

SERVERLESS_SERVICE

DATA_PATH

aws_serverless

aws_serverless2

aws_serverless3

aws_serverless4

aws_test

Challenge2-B

Challenge2-A

Challenge2-B-S

Challenge2-A-S

Challenge3-S

Challenge3

Challenge2t

Challenge2t-S

Serverless computing makes the life of a developer easy by eliminating the pains of managing servers. You only need to write code—the serverless cloud services, such as AWS Lambda Functions, take care of infrastructure on their own. The Serverless framework provides easy to use commands and dashboards to make it even easier to use cloud services.

In this course, you’ll learn what serverless computing is and how the Serverless framework works. You’ll then get hands-on experience developing and deploying an AWS Lambda Function. Next, you’ll learn how to provide additional libraries using Layers in AWS Lambda. Having covered the basics, you’ll then deploy an end-to-end machine learning pipeline to the AWS cloud with a serverless approach.

Mastery over the serverless framework will give you the ability to focus on your machine learning problem and pipeline, instead of worrying about infrastructure management. This will help you get your machine learning applications to market faster and scale them seamlessly!

Mastering Serverless Computing for Data Science

import joblib
import numpy as np
import json

model_file = "/opt/ml/model.joblib"
model = joblib.load(model_file)

def handler(event, context):
    x = event["body"]
    prd = model.predict(x)
    body = {
        "service": "sls-aws-python-starter-ml-serving-sf",
        "model": "linear",
        "version": "1.0",
        "prd": prd.tolist(),
    }

    return {
        "statusCode": 200,
        "body": body,
    }

FROM public.ecr.aws/lambda/python:3.8

# Copy function code
COPY app.py ${LAMBDA_TASK_ROOT}

# Copy trained model
RUN mkdir /opt/ml
COPY model.joblib /opt/ml/

# Install requirements
COPY requirements.txt  .
RUN  pip3 install -r requirements.txt --target "${LAMBDA_TASK_ROOT}"

# Set the CMD to your handler 
# (could also be done as a parameter override outside of the Dockerfile)
CMD [ "app.handler" ]



### Section where you define the most general settings of your application

org: ${env:SERVERLESS_ORG}
app: ${env:SERVERLESS_APP}
service: ${env:SERVERLESS_SERVICE}

frameworkVersion: '3' # It is recommend to go directly for the latest major release, if you're not in need of migrating

provider:
  ### Reference: https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml#provider
  ### Generic provider settings
  name: aws
  stage: ${opt:stage, 'dev'}
  region: ${env:AWS_REGION}
  # stackName: - It is sometimes useful to overwrite this. By default, it is {service}-{stage}
  tags: ${self:custom.defaultTags} # It is a good practice to tag your resources
  stackTags: ${self:custom.defaultTags} # It is a good practice to tag your resources
  
  ### Generic function settings
  runtime: python3.8 # Defines generic runtime for all functions or individually per function
  logRetentionInDays: 7
  # environment: - It is used to define envs available to all functions
  #   KEY: value 

  ### Deployment bucket
  deploymentBucket:
    name: ${env:AWS_BUCKET_NAME} # It is a good practice to give your pre-defined bucket that's shared for all sls deployments

  ### ECR Image
  # This will create an ECR repo where the indicated image will be pushed
  ecr:
    images:
      mlimage:
        path: '.'
        cacheFrom:
          - serverless-101:latest
  
### Section where you define plugins used by your application

custom:
  service_stage: ${self:service}-${self:provider.stage}
  defaultTags:
    App: ${self:app}
    Service: ${self:service}
    Environment: ${self:provider.stage}

### Section where you define different parameters per stage

params:
  dev:
    memory: 128
  prod:
    memory: 256

### Section where you define what files to package

package:
  individually: true # Each lambda function determines individually which files to package
  patterns:
    - "!./**" # By default excludes everything except the stuff you explicitly indicate it to keep (small and fast deployment)  

### Section where you define your functions

### Resources on Lambda functions with custom images
# https://aws.amazon.com/blogs/compute/deploying-machine-learning-models-with-serverless-templates/
# https://docs.aws.amazon.com/lambda/latest/dg/python-image.html
# https://docs.aws.amazon.com/lambda/latest/dg/images-create.html#images-create-from-base

functions:
  predict:
    # No need to indicate the handler, module, package, or anything 
    # as the function is already a part of the Docker image 
    image: mlimage
    name: ${self:custom.service_stage}-predict
    # role: ${self:custom.role_name} 
    description: This Lambda makes predictions with an ML model
    memorySize: ${param:memory} # Automatically assigns memory depending on the environment where the service is deployed
    timeout: 10



import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


Basics of Serverless Computing

ML Model Dockers in AWS Lambda

Serverless Architecture for Data Science

Conclusion

Appendix

Scalable Machine Learning Model for Accurate Predictions on AWS

Hands-On: Custom ML Docker Images in AWS Lambda

Deployment

Test yourself