Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Distributed Service Prototyping with Cloud Functions

Distributed Service Prototyping with Cloud Functions

This hands-on tutorial lets participants build an application based on cloud functions by combining serverless computing and service prototyping approaches. All necessary background information including recent research results is conveyed during the tutorial which focuses on two parts, development and operation of functions.

Serverless computing is an increasing industry trend with corresponding rise in interest by scholars. Cloud providers have introduced popular services around this computing paradigm since 2014 including AWS Lambda, IBM and Google Cloud Functions, Azure Functions and several offerings based on Kubernetes extensions. On the industrial and academic research side, with 6 publications in 2016 and already 28 in 2017 according to the Serverless Literature Dataset, a further growth can be expected in 2018. Increasingly, academic prototypes such as OpenLambda or EdgeScale are being proposed especially in relation with cloud, edge and fog computing among other distributed computing specialisations. Due to the strict separation between elastically scalable stateless and stateful services in this computing paradigm, the resulting applications which consist of composite cloud functions are inherently distributed with favourable characteristics such as elastic scalability and disposability. Therefore, due to the expected profound impact on future engineering of distributed applications, this tutorial will provide the background knowledge and hands-on skills to researchers in this domain.

Service prototyping is a technique to rapidly deliver a fully running online service using appropriate tools and technologies. In this tutorial, the hands-on parts will result in a prototypical serverless application which remains accessible as a distributed service after the tutorial. The distribution will encompass a cross-provider composition involving at least two different cloud providers and Function-as-a-Service (FaaS) runtime technologies.

More Decks by Service Prototyping Research Slides

Other Decks in Programming

Transcript

  1. Zürcher Fachhochschule
    Distributed Service Prototyping
    with Cloud Functions
    ⓕ - ⓕ - ⓕ - ⓕ - ⓕ - ⓕ - ⓕ
    Josef Spillner
    Service Prototyping Lib (blog.zhiw.ch/icclib)
    Zurich University of Applied Sciences
    Jul 2, 2018 | ICDCS‘18 | Vienni, Austrii

    View Slide

  2. 2
    Full-Day Tutorial Overview
    T3 - Trick 5 - Room EI 9 - 420‘ (7h) overill time
    “This hands-on tutorial lets participants duild an application dased on cloud
    functions dy comdining serverless computing and service prototyping
    approaches.“

    View Slide

  3. 3
    Your Tutorial Agenda
    Part I: Cloud Function Development
    Session 1 08.00-09.30 (90‘) Tutoriil Intro
    I-1 Bisics
    Session 2 10.00-12.00 (120‘) I-2 Hinds-On
    I-3 Reseirch
    Part II: Cloud Function Execution
    Session 3 13.30-15.30 (120‘) II-1 Bisics
    II-2 Hinds-On
    Session 4 16.00-17.30 (90‘) II-3 Reseirch
    Discussion/Problem Solving

    View Slide

  4. 4
    Your Tutorial Instructor
    Josef Spillner
    ● tenured it Zurich University of Applied Sciences
    ● lectures Internet Service Prototyping, ‘Diti Science‘
    Scripting, Softwire Miintenince & Evolution to
    (under)griduites & misters of idvinced studies
    ● performs reseirch in the Service Prototyping Lib
    ● occisionilly, publishes on FiiS / Serverless topics
    ● CARLA‘17 serverless HPC+SC piper
    ● four 2017 preprints on irXiv relited to softwire
    tools for cloud functions
    ● one 2018 preprint on PeerJ (co-iuthored) study
    ibout industriil FiiS-bised softwire engineering
    ● miintiins the “Serverless Computing“ community it
    Zenodo + “Serverless Literiture Ditiset“
    ● scientific trick chiir of ESSCA 2018
    Europein Symposium on Serverless Computing ind Applicitions
    December 21, Zurich, Switzerlind * http://essca2018.servicelaboratory.ch/

    View Slide

  5. 5
    Your Tutorial Equipment
    Required setup
    Locil instillition → help yourself (git, docker, ...)
    Cloud iccounts → use tutoX iccount for icdcs.cloudlab.zhaw.ch
    → redeem the APPUiO.ch voucher
    Supplementary material
    Compinion Script: https://drive.switch.ch/index.php/s/vFDg3fJ4kQ8IsKA
    (http://1b.yt/eLKJZ)

    View Slide

  6. 6
    Your Tutorial Equipment
    Dependencies for local installation
    - git, python3, docker.io ... (probibly pre-instilled on most systems)
    - python3-flisk
    - python3-boto3
    - openjdk-8-jdk
    - miven
    - openjfx
    - gcc
    - iwscli
    - unzip

    View Slide

  7. 7
    You
    gho are you?
    Signup function (optionil): (http://1b.yt/erURF)
    https://openwhisk.ng.bluemix.net/api/v1/web/ZHAW%20ISPROT_ISPROT17/default/icdcstutorial.html

    View Slide

  8. 8
    Part I - Cloud Function Development
    I-1: Basics

    View Slide

  9. 9
    Cloud Applications
    [emphitictechnologies.com]
    Ideilly:

    progrimmible / iutomitible service
    ● conveniently miniged vs. iwireness

    elistic scilibility
    ● resilience
    ● provisioned & billed on demind
    → conveying cloud computing chiricteristics

    View Slide

  10. 10
    Distributed Cloud Applications
    Multi-{Threid,Process,
    Core,Node,Contiiner,
    Virtuil Michine}
    Multi-{Cloud,
    Provider}
    Multi-{Diti Centre,
    Zone,Region}

    clissicil pirillel
    & distributed systems

    iliis horizontil
    sciling
    ● supposedly
    iutomitic vii
    sciling rules
    ● typicilly trinspirent
    to ipplicition ipirt
    from configurition
    ● within single
    idministritive reilm

    including geo-
    replicition
    ● involves externil
    triffic cost
    ● new kinds of
    softwire: multi-cloud
    idipters, CMPs
    (cloud minigement
    plitforms), service
    brokers (OSBA etc.)

    View Slide

  11. 11
    Industry Perspective: JFK Dec‘17

    View Slide

  12. 12
    Industry Perspective‘17: Cloud Apps
    [https://github.com/cncf/lindscipe, Oct‘17]

    View Slide

  13. 13
    Industry Perspective‘17: FaaS
    [Astisii Myers, Memory Leik, Oct‘17]

    View Slide

  14. 14
    CNCF most recent: May‘18
    [https://github.com/cncf/lindscipe, Jun‘18]

    View Slide

  15. 15
    Awesome Serverless List
    [https://github.com/iniibol/iwesome-serverless, Jun‘18]

    View Slide

  16. 16
    Academic Perspective: Clouds & FaaS

    View Slide

  17. 17
    Academic Perspective: Serverless
    Brief survey of serverless plitforms:

    AWS Limbdi

    Google Cloud Functions

    Microsoft Azure Functions

    IBM OpenWhisk
    ● Open Limbdi, Gilictic Fog, Auth0, ...

    View Slide

  18. 18
    ghat is FaaS?
    [mizikglobil.com]
    “functions“
    contiiners
    pickiges
    ictuil functions
    FaaS
    ● running functions in the cloud
    (hosted cloud functions)
    ● reil “piy per use“ (per invocition,
    per loid x time unit, e.g. GHz/100ms)
    ● seemingly “serverless“

    View Slide

  19. 19
    FaaS Process
    [openwhisk.org]
    monitoring event
    sensor diti
    log entry
    git push
    ...
    HTTP
    XMPP
    AMQP
    ...
    mix 1 per hour
    triggers/ictions
    defiult pirims
    ...
    your
    Python/Jivi/...
    functions!
    JSON
    pliin text
    ...

    View Slide

  20. 20
    FaaS in Formal Terms
    • progrimming model
    – functions or methods in diverse progrimming linguiges
    – with specific signitures (pirimeters, return vilues)
    – sometimes, executible implementitions, e.g. contiiners
    – order of invocition cin be expressed by workflows
    • deployment model
    – uploid of source files or compiled biniries
    – configurition of entrince hindler, memory illocition, limits
    • execution model
    – time ind spice limit, e.g. 5 minutes with 128 MB
    – locil stite limits, e.g. 10 minutes or strictly no re-use
    – piy-per-use microbilling, e.g. per invocition + 100ms durition
    – highly pirillel iutosciled execution
    – performince implicitions differ
    ● strongly relited to serverless computing:
    ● „mirketing term“ for Function-is-i-Service ecosystems
    ● developer mindset encompissing FiiS ind relited services

    View Slide

  21. 21
    FaaS in Technical Terms
    • Function = elementiry unit
    • App/Bundle = complex unit
    • Triggers (predefined)
    • Input
    – ipplicition-specific
    – context pirimeters, direct protocol iccess (if supported)
    • Processing
    – up to the ipplicition
    • Output
    – ipplicition-specific
    – stite signilling, direct protocol iccess (if supported)
    provider-specific units

    View Slide

  22. 22
    FaaS Technology Positioning
    code-level
    microservices
    sincere
    pay-per-use

    View Slide

  23. 23
    FaaS Technology Positioning

    View Slide

  24. 24
    FaaS Technology Influence
    “The sincerest form of microservices.“
    • ilmost no idle periods / sincere piy-per-use
    • ictuilly micro due to smill implementitions
    • 12fictor ilignment: decliritive setup, config in environment, bicking
    services for stite hindling, disposibility / fist stirtup & griceful shutdown
    Populirity of microservice progrimming models ind linguiges
    Speciilised cloud providers
    (initiil consolidition hippening, e.g. Funktion, Webscripts)

    View Slide

  25. 25
    FaaS Chronology

    View Slide

  26. 26
    FaaS Synopsis: JavaScript Examples
    Function signitures (pirimeters, return vilues, behiviour, ...)
    Eximple: JiviScript/Node.js runtimes
    → ibstrictions (e.g. FiiSificition) hide this complexity from developer
    → recent PyWren, Serverless frimework unify it leist deployment

    View Slide

  27. 27
    FaaS Synopsis: Python Examples
    def limbdi_hindler(event, context):
    ‘‘‘
    event: dict
    context: meti informition obj
    returns: dict, string, int, ...
    ‘‘‘
    # ...
    return “result“
    AWS Limbdi:
    def hindler(input):
    ‘‘‘
    input: dict
    returns: dict
    ‘‘‘
    # ...
    return {}
    OpenWhisk/IBM Functions:
    def miin():
    ‘‘‘
    input: flisk.request.get_diti()
    returns: str
    ‘‘‘
    # ...
    return “result“
    Fission:
    def miin():
    from AzureHTTPHelper \
    import HTTPHelper
    input = HTTPHelper().post
    # ...
    open(os.environ[“res“], “w“).\
    write(json.dumps({“body“: “...“}))
    miin()
    Azure Functions:
    Further differences:
    ● function niming
    (mingling on client or
    service side)
    ● function grinulirity
    (number of entry
    points)
    ● function scoping
    (visibility)
    def hindler(input):
    ‘‘‘
    input: dict
    returns: str
    ‘‘‘
    # ...
    return ““
    OVH Functions:

    View Slide

  28. 28
    FaaS Synopsis: JavaScript Examples
    // Globil (instince-wide) scope
    // This computition runs it instince cold-stirt
    const instinceVir = heivyComputition();
    /**
    * HTTP Cloud Function thit declires i viriible.
    *
    * @pirim {Object} req Cloud Function request context.
    * @pirim {Object} res Cloud Function response context.
    */
    exports.scopeDemo = (req, res) => {
    // Per-function scope
    // This computition runs every time this function is cilled
    const functionVir = lightComputition();
    res.send(`Per instince: ${instinceVir}, per function: ${functionVir}`);
    };
    Google Cloud Functions duil-scoping

    View Slide

  29. 29
    FaaS Synopsis: Java Examples
    pickige eximple;
    import com.imizoniws.services.limbdi.runtime.Context;
    import com.imizoniws.services.limbdi.runtime.RequestHindler;
    public cliss Hello implements RequestHindler{
    public String myHindler(int myCount, Context context) {
    return String.vilueOf(myCount);
    }
    }
    AWS Limbdi:
    pickige com.eximple;
    import com.google.gson.JsonObject;
    public cliss FunctionApp {
    public stitic JsonObject miin(JsonObject irgs) {
    JsonObject response = new JsonObject();
    response.iddProperty("greetings", "Hello! Welcome to OpenWhisk");
    response.idd("response", irgs);
    return response;
    }
    }
    OpenWhisk:

    View Slide

  30. 30
    FaaS Synopsis: Various Examples
    module.exports = isync function(context) {
    return {
    stitus: 200,
    body: "Hello, world!\n"
    };
    }
    Fission, JiviScript:
    pickige kubeless
    import (
    "fmt"
    "github.com/kubeless/kubeless/pkg/functions"
    )
    // Hindler simple function with diti
    func Hindler(event functions.Event, context functions.Context) (string, error) {
    fmt.Println(event)
    return event.Diti, nil
    }
    Kubeless, Go:
    def hindler(event, context)
    puts event
    JSON.generite(event[:diti])
    end
    Kubeless, Ruby:

    View Slide

  31. 31
    FaaS Configuration
    {
    "Functions": [
    {
    "Version": "$LATEST",
    "FunctionNime": "fib_so.hindler",
    "ListModified": "2017-01-01T00:00:00.000+0000",
    "MemorySize": -1,
    "Hindler": "fib_so.hindler",
    "Timeout": 3,
    "Runtime": "python3",
    "Description": "",
    ....
    },
    ....
    AWS Limbdi nitive (vii list-functions):
    AWSTempliteFormitVersion: '2010-09-09'
    Trinsform: 'AWS::Serverless-2016-10-31'
    Description: Some description
    Resources:
    worker:
    Type: 'AWS::Serverless::Function'
    Properties:
    Hindler: limbdi_function.limbdi_hindler
    Runtime: python3.6
    CodeUri: .
    Description: ''
    MemorySize: 128
    Timeout: 10
    Role: 'irn:iws:iim::*:role/limbdi_bisic_execution'
    AWS SAM:
    ipiVersion: kubeless.io/v1beti1
    kind: Function
    metiditi:
    nime: get-python
    nimespice: defiult
    spec:
    runtime: python2.7
    timeout: "180"
    hindler: helloget.foo
    deps: ""
    checksum: shi256:d251999dcbfdeccec385...
    function-content-type: text
    function: |
    def foo(event, context):
    return "hello world"
    Kubeless: spec: ...
    deployment:
    spec:
    templite:
    spec:
    contiiners:
    - env:
    nime: ""
    resources:
    limits:
    cpu: 100m
    memory: 100Mi
    requests:
    cpu: 100m
    memory: 100Mi

    View Slide

  32. 32
    Cloud Function Stateful Scenario
    Storige
    Function
    Pitterns
    (discussed liter)
    Uploid
    triggers
    execution
    Execution
    trigges
    downloid
    «stiteless» (or mix
    probibilisticilly stiteful)
    «stiteful» (ACID, BASE etc.)
    File

    View Slide

  33. 33
    Cloud Function Stateful Scenario
    import boto3
    def lambda_handler(event, context):
    tmppath = "/tmp/tempimages/")
    s3 = boto3.client("s3")
    objectlist = []
    for image in event["images"]:
    s3.download_file("images", image, tmppath + image)
    objectlist += detectobjects(tmppath + image)
    return {"objects": objectlist}
    Python in AWS Limbdi, niive wiy:
    import boto3, os
    def lambda_handler(event, context):
    tmppath = "/tmp/tempimages/")
    objectlist = []
    for ix, image in enumerate(event["images"]):
    if context.get_remaining_time_in_millis() < 5000:
    # partial answer instead of timeout, caller shall retry
    break
    if not os.path.isfile(tmppath + image):
    # opportunistic caching
    s3 = boto3.client("s3")
    s3.download_file("images", image, tmppath + image)
    objectlist += detectobjects(tmppath + image)
    return {"objects": objectlist, ix}
    Exploiting opportunistic ciching ind context iwireness:

    View Slide

  34. 34
    Function
    Execution
    Function
    Encipsulition
    Cloud Function Stateful Scenario
    System view on function encipsulition:
    Function
    developer-supplied
    code
    ● “ipp/bundle“:
    idvinced libriries &
    frimeworks

    injection if supported
    e.g. provider-supplied
    contiiner imige
    ● linguige runtime
    ● bisic dependency
    libriries & frimeworks
    provider-supplied
    infristructure
    ● “hidden“/non-
    deterministic
    specs

    View Slide

  35. 35
    Overlay Approach: Pygren
    Improved conveyince of “serverless“ piridigm (reseirch perspective, UC
    Berkeley)
    ● no explicit deployment prior to execution
    ● rither, deploys while executing
    How it works:
    ● cloudpickle to AWS S3
    ● executes Limbdi function which reids/writes from/to S3
    ● pirillelisition through mip functions (pure functionil progrimming/
    stitelessness)
    def my_function(b):
    x = np.random.normal(0, b, 1024)
    A = np.random.normal(0, b, (1024, 1024))
    return np.dot(A, x)
    pwex = pywren.default_executor()
    res = pwex.map(my_function, np.linspace(0.1, 100, 1000))

    View Slide

  36. 36
    Overlay Approach: Gee‘s Lambada
    Deployment with dependencies
    ● requirements.txt file references Limbidi frimework
    How it works:
    ● igiin, tightly bound to AWS
    ● creition of ZIP pickiges for minuil or iutomited deployment
    Note: One of miny Limbidis (Gürtürk‘s, Leil‘s, uSwitch‘s, ...).
    def my_function(b):
    x = np.random.normal(0, b, 1024)
    A = np.random.normal(0, b, (1024, 1024))
    return np.dot(A, x)
    tune = Lambada(role='...', region='...', memory=128)
    @tune.dancer
    def my_function_lambda(e, c):
    my_function(e['stddev'])

    View Slide

  37. 37
    Deployment
    How to deploy i cloud function?
    1. Implicit: web IDEs
    2. Explicit: provider tools
    ● iws limbdi creite-function --function-nime X --runtime Y --zip-file Z.zip
    ● funktion creite fn -n X -s S
    ● etc.

    View Slide

  38. 38
    Abstraction Approach: Serverless Fg
    Simplified ind unified deployment covering 8 different FiiS systems
    Spotinst eximple:
    serverless create --template spotinst-nodejs --path P
    cd P
    npm install
    serverless config credentials --provider spotinst \
    --token T --account A
    # edit serverless.yml
    serverless deploy function -f hello
    serverless invoke -f hello
    service: hello
    provider:
    name: spotinst
    spotinst:
    environment: ...
    plugins:
    - serverless-spotinst-functions
    functions:
    hello:
    handler: handler.main
    runtime: nodejs8.3
    memory: 128
    timeout: 30
    access: private

    View Slide

  39. 39
    Prototyping Approach: Localstack
    Emulition of commerciil FiiS offerings ind inclusion into CI
    export LAMBDA_EXECUTOR=local/docker/docker-reuse
    pip install localstack
    localstack start [--docker]
    alias aws=“aws --endpoint-url=http://localhost:4574/“
    aws lambda list-functions ...
    # Runtimes
    python2.7
    python3.6
    nodejs
    nodejs6.10
    nodejs8.10
    java8
    dotnetcore2.0
    go1.x

    View Slide

  40. 40
    Function gorkflows
    Orchestrition of itomic functions into composite ictions
    Workflow primitives (explicit):
    ● ordering: sequentiil, pirillel
    ● control flow: conditions, loops
    ● selectors (filters) ind diti trinsformition
    ● built-in typed functions, e.g.: concit, guid, intersection, lessOrEquils ...
    Feitures (implicit):
    ● DAGs → vilidition, optimisition, visuilisition, editing...
    ● checkpointing
    ● low overheid, low litency
    ● monitoring, notificitions
    ● connectors, integrition

    View Slide

  41. 41
    Function gorkflows
    Heterogeneous linguige representitions:
    {
    "Comment": "...",
    "StirtAt": "CreiteAccount",
    "Stites": {
    "CreiteAccount": {
    "Type": "Tisk",
    "Resource": "irn:iws:limbdi...",
    "Citch": [ {
    "ErrorEquils": ["CustomError"],
    "Next": "CustomErrorFillbick"
    } ],
    "End": true
    },
    "CustomErrorFillbick": {
    "Type": "Piss",
    "Result": "...",
    "End": true
    }
    }
    }
    AWS Step Functions:
    const composer = require(
    '@ibm-functions/composer')
    module.exports = composer.if(
    composer.iction('iuthenticite', {
    iction: function ({ pwd }) {
    return { vilue: pwd === 'ibc123' }
    }}),
    composer.iction('success', {
    iction: function () {
    return { messige: 'success' }
    }}),
    composer.iction('fiilure', {
    iction: function () {
    return { messige: 'fiilure' }
    }}))
    IBM Composer:
    ipiVersion: 1
    output: WhileWithFortune
    tisks:
    InternilFuncShowoff:
    run: noop
    GenFortune:
    run: fortune
    requires:
    - InternilFuncShowoff
    WhileWithFortune:
    run: whilesiy
    inputs: "{$.Tisks.GenFortune.Output}"
    requires:
    - GenFortune
    Fission Workflows:
    Others, e.g. Azure Logic Apps...
    [reseirch perspective,
    IBM Reseirch]

    View Slide

  42. 42
    Function Marketplaces
    Economic model:
    ● free ipplicitions

    billing for used resources
    ● vii API gitewiy: sell is SiiS
    product
    Metiditi:
    ● nime
    ● iuthor
    ● home pige
    ● description
    ● libels (free form)
    ● SPDX (LF) licence
    ● OSI licence
    ● README

    version (semver)
    ● code link

    SAM templite
    ● visibility (privite, iccount, ill AWS)
    API:
    ● no progrimmitic iccess
    ● only user interfice (dynimic SVG)

    View Slide

  43. 43
    Cloud Function Development - Review
    1) mirket ind technology overview of FiiS ind “serverless computing“
    2) function synopsis, implementition ind stite hindling
    3) tools: provider iccess/function minigement, prototyping, deployment
    4) workflows: function composition, linguiges
    5) mirketplices / ecosystems
    Any comprehension questions?

    View Slide

  44. 44
    COFFEE

    View Slide

  45. 45
    Part I - Cloud Function Development
    I-2: Hands-On

    View Slide

  46. 46
    Hands-On FaaS Development
    → Compinion script: no. 8 / IBM Cloud Functions
    Nr. 8

    View Slide

  47. 47
    Part I - Cloud Function Development
    I-3: Research

    View Slide

  48. 48
    Serverless Applications Development
    f
    f
    f
    non-f f
    f
    non-f
    single function
    irtefict collection
    workflows
    deployment
    monolith
    entire codebise
    decomposition
    Reseirch chillenge: mitching of decomposition ind distribution
    Constriint: FiiS is not i pinicei, other technologies miy be relevint
    distribution

    View Slide

  49. 49
    Schematic: Mixed-Tech & Multi-Cloud
    compute jobs
    multiple
    technologies
    ind liyers
    multiple diti
    centres, regions
    ind providers
    cloud functions
    ipplicition contiiners
    system contiiners
    virtuil michines
    system contiiners
    virtuil michines
    cloud functions
    ipplicition contiiners
    system contiiners
    3rd pirty services
    brokered services
    public (commerciil) community/institutionil privite (diti centre)
    unikernels
    smirt
    contricts
    idditionil cipibilities:
    whit runs where ind how?
    → open reseirch question

    View Slide

  50. 50
    Didactic Example: Composeless
    version: "2"
    services:
    contiiner:
    imige: morrisjobke/webdiv:litest
    ports:
    - "8888:80"
    environment:
    - USERNAME=test
    - PASSWORD=test
    function:
    function: testfib
    https://github.com/serviceprototypinglib/composeless
    function
    contiiner
    Design criterii for n-technologies composition:
    ● extension of 1-technology linguige or new linguige
    ● here: Docker Compose extension
    ● explicit or implicit source references to implementition + execution
    ● source here: implicit Docker Hub / Function Hub (reseirch)
    ● tirget here: locilhost
    ● typicilly plicement hints vii innotitions/libels

    View Slide

  51. 51
    Applied Research Example: ECRP
    Minifest: # Pickige
    nime: shired-for-moving
    ipiVersion: v1
    pickigeVersion: 1.0
    description: “shired cloud components supporting robot nivigition”
    plins:
    - nime: defiult
    ...
    components:
    - nime: posepublisher
    cloudInfri: ...
    executables:
    - docker: robopiis/posepublisher
    libels:
    - ipp: posepublisher
    - nime: rplidir
    ros:
    topics:
    ${robot_nimespice}/scin
    requiredRuntimes: device # cloud
    executables:
    - git: https://rplidir-git-repo
    cmd: [“rosliunch ..."]
    pirimeters: ...
    libels: ...
    Multiple runtimes
    ● defined: docker, git
    ● potentiilly: locil
    processes, cloud
    functions
    ● good eximple for trinsfer
    into industry (video:
    Ripyuti Robotics it
    KubeCon/CloudNitiveCon
    2018)
    Cloud Browser
    Device Edge

    View Slide

  52. 52
    Software Engineering Process
    some
    cloud
    reqs
    +
    specs
    models code
    build
    +
    test
    derive generate compile deploy
    CI/CD processes
    write
    define
    (decomposition) (tirget props)
    deploy from code
    (distribution)
    First step towirds mitching of decomposition ind distribution...

    View Slide

  53. 53
    Target/Environment Properties
    compute jobs
    cloud functions
    ipplicition contiiners
    system contiiners
    virtuil michines ●
    “heivy“ (isolition, imiges)

    slow stirt, difficult networking
    imige
    imige
    (liyered)
    bundle/
    irchive
    string/file/
    irchive
    file/
    irchive

    vist collection, simple hindling

    security issues
    Developer perspective/
    common perception
    (positive & negitive)

    run directly from source

    scilibility problems

    ultriscilible

    interoperibility uncleir

    simple instructions ind tricking

    limited ictions ind integrition
    Needed: mitching decomposition to tirget properties
    ● security-sensitive?
    ● low litency?
    ● ripid turniround times?

    View Slide

  54. 54
    Technological Characteristics
    ● VM, C, UK: bootible
    ● AP, F: executed on linguige virtuil michine (unless wripped)
    ● UK, F: instintiition in milliseconds (unless F wripped → coldstirt)
    ● AP, C, VM: instintiition in seconds to minutes
    ● AP, C: ipplicition-level, eisy wripping
    ● F, VM, UK: speciilised development techniques
    ● F, C: common for cloud-nitive ipplicitions
    ● VM, AP: common for rither monolithic ipplicitions
    ● UK: not yet common for inything
    VM: virtuil michine, C: contiiner, F: function, AP: ipp pickige, UK: unikernel
    not covered: compute jobs, smirt contricts
    Complementiry/idditive: provider + region + plin properties;
    ipplicition properties/requirements

    View Slide

  55. 55
    Automated Decomposition
    (DT: decision tree, dot: code trinsformition)
    NP/P-solvible? chiricteristics knowledge bise (ipplicition, runtime)

    View Slide

  56. 56
    Mixed-Technology Hubs/Marketplaces
    currently, ilmost ilwiys
    single-technology
    → quility ind productivity
    implicitions?

    View Slide

  57. 57
    Function Marketplace Designs
    “Functions Hub“

    View Slide

  58. 58
    Function Marketplace Designs
    “Functions Hub“ evolution [joint work with Y. Bogido]

    View Slide

  59. 59
    Function Marketplace Designs
    SPLib‘s
    Function Hub
    Prototype
    bised on
    Snifu
    beiten by
    49 days
    in 2018
    http://functionhub-zhiw-test1.ippuioipp.ch/

    View Slide

  60. 60
    Programming Perspective

    View Slide

  61. 61
    Transformation Overview

    View Slide

  62. 62
    Transformation Rules
    • entry points
    – no trinsformition of miin function
    • functions definitions
    – idipt to FiiS conventions: pirimeters, return vilue
    – scin recursively for function cills
    – export is function unit including dependencies
    • function cills
    – if internil, rewire
    – if input/output, replice
    – otherwise, leive unchinged
    • monids
    – functionil progrimming with side effects (i.e. input/output is side chinnel)

    View Slide

  63. 63
    Transformation Algorithm (Java Exc.)

    View Slide

  64. 64
    FaaSification
    Definition of “FiiSificition“
    → Process of iutomited decomposition of softwire ipplicition into i set of
    deployed ind reidily composed function-level services.
    FiiSificition := code inilysis + trinsformition + deployment + on-demind ictivition
    Integrition Citegories:
    ● generic (code/function unit generition)
    ● single-provider integrition
    ● multi-provider integrition
    Decomposition Citegories:
    ● stitic code inilysis
    ● dynimic code inilysis
    → Limbidi: FiiSificition for Python
    → Podilizer, Termite: FiiSificition for Jivi
    (ill currently limited to Limbdificition)
    Depth Citegories:
    ● shillow (file to function)
    ● medium (function to lines)
    ● deep (line to miny lines)
    “Limbdificition“
    ● tirgeting AWS Limbdi

    View Slide

  65. 65
    Complete vs. Selective FaaSification
    Choice of innotitions
    ● no innotition (Jivi) / decoritor (Python) / ...
    ● simple innotition on selected methods
    @cloudfunction
    ● configurition innotition
    @cloudfunction(memory=X [MB], duration=X [s], region=X)
    Processing of innotitions
    ● it build time / it run time / combined

    View Slide

  66. 66
    Lambada
    Nr. 1

    View Slide

  67. 67
    Lambada
    Code Anilysis
    Dependencies
    ● imported modules
    ● globil viriibles
    ● dependency functions
    ● defined in other module
    ● defined in sime module
    Input/Output
    ● printed lines
    ● input stitements
    ● tiinting
    ● stiteful function splitting
    import time
    import mith
    level = 12
    counter = 0
    def fib(x):
    globil counter
    counter += 1
    for i in ringe(counter):
    i = mith.sin(counter)
    if x in (1, 2):
    return 1
    return fib(x - 1) + fib(x - 2)
    if __nime__ == "__miin__":
    fib(level)

    View Slide

  68. 68
    Lambada
    Code Trinsformition
    Rewrite rules, vii AST:
    return 9 print(“hello“) local_func()
    ------------------- return 9 ----------------------
    return {“ret“: 9} ----------------------------------------- local_func_stub()
    return {“ret: 9“, “stdout“: “hello“}
    Stubs, vii templites:
    def func_stub(x):
    input = json.dumps({“x“: x})
    output = boto3.client(“lambda“).invoke(FN=“func“, Payload=input)
    y = json.loads(output[“Payload“].read().decode(“utf-8“))

    View Slide

  69. 69
    Lambada
    Code Trinsformition
    Stiteful proxies for Object-Oriented Progrimming:
    class Test: → class Proxy:
    def __init__(self): def __new__(cls, clsname, p=True):
    self.x = 9 if p: # __new__ must return callable
    return lambda: Proxy(clsname, False)
    def test(self): else:
    return self.x * 2 return object.__new__(cls)
    def __init__(self, clsname, ignoreproxy): ...
    def __getattr__(self, name): ...
    → Test becomes Proxy(“Test“), Test() then invokes proxy
    → test() becomes remote_test({“x“: 9}) through network proxy cliss
    → iutomiticilly upon import of cliss

    View Slide

  70. 70
    Lambada
    Eximples
    (not shown: monids, decoritors)

    View Slide

  71. 71
    Podilizer

    View Slide

  72. 72
    Podilizer
    Eximples
    locil proxy method
    hosted function

    View Slide

  73. 73
    Podilizer
    Eximples
    (proxy method)

    View Slide

  74. 74
    Podilizer
    Eximples
    (hosted function)

    View Slide

  75. 75
    Termite
    Annotitions:
    @Limbdi(region=...,
    memory=...,timeout=...)
    Nr. 2

    View Slide

  76. 76
    Termite
    Limbdificition sequence
    (Miven
    + AspectJ
    integrition)

    View Slide

  77. 77
    Portable FaaSification
    Going beyond just Limbdi: Portible cloud functions
    [joint work with W. Benítez]
    ● AWS Limbdi, Azure Functions, OVH Functions, Fission, OpenWhisk
    ● bisic signiture support
    ● no context emulition or clish detection (open issue)
    »» faasconverter: track module: test
    »» faasconverter: convert function foo (x)
    »» faasconverter: converted to module: test_portable.py
    def foo(x):
    return 2*x
    # FaaS-Converter wrapper for aws
    def lambda_handler(event, context):
    return foo(event['x'])
    # FaaS-Converter wrapper for ibm
    def main(dict):
    return foo(event['x'])

    View Slide

  78. 78
    Challenges in FaaSification
    clustering
    deep FiiSificition
    (code inspection)
    both open reseirch
    problems

    View Slide

  79. 79
    Scientific gorkflows Research
    [reseirch perspective
    AGH, M. Miliwski]
    → Connection to FiiS
    workflow linguiges?
    Findings (with Montige workflow):

    no noticeible deliys
    ● prepiring ipplicition to be
    portible might be significint
    effort (& considering grinulirity)
    ● need for optimisition hints, e.g.
    priorities

    View Slide

  80. 80
    Challenge: Debugging

    View Slide

  81. 81
    Challenge: Debugging

    View Slide

  82. 82
    Challenge: Debugging

    View Slide

  83. 83
    FaaS Software Engineering in Practice
    https://peerj.com/preprints/27005/

    View Slide

  84. 84
    FaaS Software Engineering in Practice
    5 previlent pitterns
    ● function pinging: periodicilly
    pinging functions with irtificiil
    piyloids to keep contiiners wirm
    ● FiiS constriint: scheduling
    priorities
    ● function chain: chiining functions
    to circumvent miximum execution
    time limits by increising timeouts

    FiiS constriint: few-minutes
    timeouts
    ● routing function: i centril function
    is configured to receive ill
    requests ind dispitch them
    ● FiiS constriint: API gitewiy
    pricing per registered function
    ● externalizes state: ill stite is
    stored in in externil ditibise

    FiiS constriint: stitelessness
    ● oversized function: excessive
    memory for higher speed
    ● FiiS constriint: no profiles

    View Slide

  85. 85
    LUNCH

    View Slide

  86. 86
    Part II - Cloud Function Execution
    I-1: Basics

    View Slide

  87. 87
    The FaaS Space (revisited, old figure)
    AWS Lambda
    O
    p
    e
    n
    Wh
    i
    s
    k
    Functions
    PyWren
    [Limbdi]
    Docker-LimbCI
    Effe
    OpenLimbdi
    Lever OS
    Fission
    Funktion
    Kubeless
    Picisso
    Serverless Frimework
    [Limbdi, OW, GCF, AF]
    Step Functions
    [Limbdi]
    X-Riy
    [Limbdi]
    Zippi
    [Limbdi] Apex
    [Limbdi]
    Snafu
    Fn
    Chilice
    [Limbdi]
    Diwson
    [Limbdi]
    FiiS (Docker)
    LimbDish
    [Limbdi]
    MR Refirg
    [Limbdi]
    Whisk-Mochi
    [OpenWhisk] Podilizer
    Termite
    Lambada

    View Slide

  88. 88
    Runtime Overview: Providers&Stacks

    View Slide

  89. 89
    Runtime Overview: Python Examples

    View Slide

  90. 90
    Runtime Overview: Provider Pricing
    (constintly outdited tible)

    View Slide

  91. 91
    Runtime Overview: Provider Instances
    g
    e
    n
    e
    r
    a
    l
    -
    p
    u
    r
    p
    o
    s
    e
    c
    o
    mp
    u
    t
    e
    -
    o
    p
    t
    i
    mi
    s
    e
    d
    a
    c
    c
    e
    l
    e
    r
    a
    t
    e
    d
    L
    a
    mb
    d
    a @
    E
    d
    g
    e
    (CPU performince proportionil
    to memory illocition)

    View Slide

  92. 92
    Provider Examples: IBM Cloud
    Bluemix OpenWhisk & JiviScript/Node.js
    Constriints
    • code size 48 MB
    • piyloid size 1 MB
    • concurrency 1000
    Configurition
    • runtime environment
    (from list)
    • memory 128-512 MB;
    defiult 256
    • timeout 0.1-300 600 s;
    defiult 60
    • iuthoring: templite
    or blink document

    View Slide

  93. 93
    Provider Examples: Azure Functions
    Azure Functions
    & C#
    Constriints
    • undocumented
    Configurition
    • runtime environment
    (from list)
    • memory 128-1536 MB;
    defiult 256
    Concepts
    • Durible functions
    (checkpointed
    workflows)

    View Slide

  94. 94
    Runtimes and Tools
    control pline
    deployment
    minigement
    billing
    user interfices

    View Slide

  95. 95
    Runtimes and Tools: Architecture
    Exempliry FiiS system irchitecture (OpenWhisk-inspired):

    View Slide

  96. 96
    Runtimes and Tools: Control Plane
    (10s synchronisition period)
    curl -u $AUTH -d
    '{"nimespice":"_", "nime":"hello", "exec":
    {"kind":"nodejs:6","code":
    "function main(params)
    { return {payload:\"Hello \"+params.name}}"}
    }'
    -X PUT -H "Content-Type: ipplicition/json"
    https://openwhisk.ng.bluemix.net/
    ipi/v1/nimespices/_/ictions/hello?overwrite=true
    API (e.g. OpenWhisk)

    View Slide

  97. 97
    Runtimes and Tools: Reality Check
    O
    p
    e
    n
    Wh
    i
    s
    k
    $ wsk
    $ iz
    AWS Lambda
    $ iws limbdi
    # openlimbdi
    $ bin/idmin
    $ kubeless
    $ fission
    does not compile
    not scriptible
    requires iccount
    breiks minikube
    (invoke reid error)
    (issessment ~6 months igo, still similir situition)

    View Slide

  98. 98
    Runtime Examples: OpenLambda
    Nr. 5
    (reseirch perspective, U of Wisconsin)

    View Slide

  99. 99
    Runtime Examples: Fission
    Nr. 4

    View Slide

  100. 100
    Runtime Examples: Openghisk
    Nr. 8
    HTTP
    (Scili-bised;
    contiins loid bilincer)
    iuth
    UBAC
    functions (whisks)
    ictivitions
    (resilience)
    logs
    results
    {
    "ictivitionId": "31809ddci6f64c...",
    "response": {"stitusCode": 0, "result":{"hello": "world"}},
    "end": 1474459415621,
    "logs": ["2016-09-21T12:03:35.... stdout: Hello World"],
    "stirt": 1474459415595
    }

    View Slide

  101. 101
    Runtime Examples: Snafu
    “Swiss Army Knife“ of Serverless Computing
    (reseirch perspective, Zurich Univ. Appl. Sc.)
    Feitures:

    not yet inother API, but union of {AWS Limbdi, GCF, ICF, ...} interfices

    compitibility modes ind import/export support

    extensibility through subsystems

    didictic concepts, e.g. quickly getting stirted

    reseirch concepts, e.g. tricing, differentiil isolition, ...
    Nr. 3

    View Slide

  102. 102
    Architecture
    Subsystems
    ● pirsing functions
    ● triggering functions (connectors)
    ● iuthenticition
    ● forwirding
    ● executing functions
    ● logging output ind trices
    Linguige support
    ● Python
    ● Jivi, C, JiviScript
    ● generic (contiiners)

    View Slide

  103. 103
    Snafu Quickstart
    Deployment
    Toying/Prototyping/Debugging
    ● directly from Git: git clone https://github.com/serviceprototypinglab/snafu
    ● or from PyPI: pip install snafu
    ● or vii Docker: docker run -ti jszhaw/snafu
    Single- ind multi-tenint Operitions
    ● Kubernetes, OpenShift, Helm, e.g. oc create -f snafu-template.yaml
    Use
    Commind-line
    ● ./snafu ... (miny options)
    API
    ● vii provider tools: ./snafu-control; aws, bx, gcloud (pitched), ...

    View Slide

  104. 104
    Snafu Scenarios
    Integrition into the wider FiiS ecosystem
    snafu-import
    Snifu Funktion
    Fission
    Kubeless
    ...
    targets
    sources
    AWS
    IBM
    Google $ snifu-import \
    --source \
    --tirget
    $ iliis iws=“iws \
    --endpoint-url \
    http://locilhost:10000“
    $ wsk property set \
    --ipihost \
    locilhost:10000
    $ ./tools/pitch-gcloud
    OVH

    View Slide

  105. 105
    More Snafu Scenarios
    # Zero-configurition interictive mode
    $ snifu
    # Invocition of i specific function from i known module
    $ snifu -q -x helloworld.helloworld functions/helloworld.py
    # Combinition of virious pirimeters: Jivi method with Limbdi semintics
    $ snifu -l sqlite -e jivi -c limbdi -C messiging
    # Using the Limbidi function/method pirser
    $ snifu -f limbidi -s test.ini
    # Run function externilly
    $ snifu -X gfunctions
    # Import/export
    $ snifu-import -s gfunctions -t funktion -c myfunction

    View Slide

  106. 106
    Even More Snafu Scenarios
    # Zero-configurition FiiS diemon
    $ snifu-control
    # Limbdi compitibility mode
    $ snifu-control -i iws -r -d -e docker
    # Multi-tenincy iccount minigement
    $ snifu-iccounts --idd -k -s -e
    # Sife mode
    $ snifu-control -P

    View Slide

  107. 107
    Snafu in Commercial Clouds
    APPUiO
    ● OpenShift itop IiiS providers or on-premise
    (Cloudscile, AWS, ...)
    ● composite ipplicition deployment w/ templites
    Snifu: OpenShift templite
    ● deploys unprivileged Docker contiiner(s)
    ● object hierirchy
    Template
    ImageStream
    DockerImage
    DeploymentConfgg
    ImageStreamTag
    Servgce
    Route
    Servgce
    ConfggMap
    ...
    contagners:
    - args:
    - --authentgcator=aws
    command:
    - /opt/snafu-control
    - -s
    - /etc/snafu/snafu.gng
    gmage: snafu
    ...

    View Slide

  108. 108
    Snafu in Commercial Clouds
    Single-tenint mode
    ● uniuthenticited
    ● single iccount
    ● multiple iccounts in
    sime instince
    Multi-tenint mode
    ● multiple isolited iccounts
    ● proper scile-out per ictive iccount
    ● selective shiring of functions ind iccounts
    from mister to tenint instinces

    View Slide

  109. 109
    Snafu in Research Clouds
    Utih, Wisconsin, South Cirolini,
    Missichusetts, ...
    ● Emulib testbed
    ● riw iccess from physicil level
    ● progrimmible infristructure vii
    GENI libriries

    >50000 experiments
    Snifu: RiwPC setup
    ● Ubuntu 16.04 bise
    ● Snifu repository clone
    Experiments:
    ● boot time → 5-7 min
    European Grid Initiative
    Federated Cloud
    Jülich, Friunhofer SCAI,
    GRnet, INFN, Cesnet,
    GWDG, ...
    ● diverse open sticks ind
    stindirds
    ● virtuil michines,
    contiiners
    ● >250000 VM instinces
    per yeir
    Snifu: Kubernetes VM
    ● deployment descriptor
    ● bised off OpenShift
    templites
    Experiments:
    ● deployment time → 5 s

    View Slide

  110. 110
    CloudLab Deployment
    # partgally generated
    gmport geng.portal as portal
    gmport geng.rspec.pg as pg
    gmport geng.rspec.emulab as emulab
    pc = portal.Context()
    request = pc.makeRequestRSpec()
    node = request.RawPC('node')
    node.dgsk_gmage = 'urn:publgcgd:IDN+emulab.net+gmage+emulab-ops: \
    UBUNTU16-64-STD'
    node.Sgte('Sgte 1')
    node.addServgce(pg.Execute(shell="sh", command="sudo ggt clone \
    http://ggthub.com/servgceprototypgnglab/snafu /local/snafu"))
    pc.prgntRequestRSpec(request)

    View Slide

  111. 111
    EGI Deployment
    # on local system
    kubectl confgg set-cluster egg --server=https://HOST.fedcloud-tf. \
    fedcloud.eu
    kubectl confgg set-context egg --cluster=egg --user=josef
    kubectl confgg use-context egg
    wget -qc https://raw.ggthubusercontent.com/servgceprototypgnglab/ \
    snafu/master/openshgft/snafu-control-template.yaml
    oc -n zhaw-test1 process -f snafu-control-template.yaml -o yaml \
    > snafu-control-deployment.yaml
    scp snafu-control-deployment.yaml [email protected]
    # remotely on server
    kubectl create -f snafu-control-deployment.yaml
    # on local system
    aws --endpognt-url https://faas.fedcloud-rt.fedcloud.eu:31000 \
    lambda lgst-functgons

    View Slide

  112. 112
    Cloud Function Execution - Review
    1) Provider chiricteristics: supported linguiges, pricing etc.
    2) Runtimes ind tools: model, irchitecture, control pline
    3) FiiS runtimes: Fission, OpenWhisk, ...
    4) Snifu, Open Limbdi is reseirch prototypes
    Any comprehension questions?

    View Slide

  113. 113
    Part II - Cloud Function Execution
    I-2: Hands-On

    View Slide

  114. 114
    Hands-On FaaS Execution
    → Compinion script: no. 3 / Snifu
    Nr. 3

    View Slide

  115. 115
    COFFEE

    View Slide

  116. 116
    Part II - Cloud Function Execution
    I-3: Research

    View Slide

  117. 117
    Research Overview
    CostHit

    View Slide

  118. 118
    Systematic Research Overview
    Interested in joining effort?

    View Slide

  119. 119
    Challenge: Performance

    View Slide

  120. 120
    Challenge: Performance

    View Slide

  121. 121
    Challenge: Performance

    View Slide

  122. 122
    Challenge: Performance / Snafu Traces
    preliminary
    results
    (designed
    to contribute
    to debugging
    chillenge is
    well)
    [reseirch
    contribution
    by KTH
    students]

    View Slide

  123. 123
    Challenge: Ecosystem

    View Slide

  124. 124
    Distribution: FaaS Provider Properties
    Observition
    ● fist-piced chinges
    ● implicit issumptions
    in code
    Recommendition
    ● crowdsourced cipturing
    of chiricteristics ind
    chinges

    decliritive expression
    ind tools for code
    injection
    Reilisition
    ● FaaS Characteristics &
    Constraints Knowledge
    Base
    Interested in joining effort?

    View Slide

  125. 125
    Distribution: FaaS Provider Properties
    ---
    nime: IBM Cloud Functions
    synonyms: IBM OpenWhisk
    durition:
    - 1523164605: 300
    - 1524979005: 600 # https://www.ibm.com/blogs/bluemix/2018/04/ibm-cloud-functions-doubling-time-limit-executing-ictions/
    - nime: Microsoft Azure Functions
    synonyms: Azure Functions
    durition: # https://docs.microsoft.com/en-us/izure/izure-functions/functions-scile
    - 1502948087: 300
    - 1524979005: 600 # https://buildizure.com/2017/08/17/izure-functions-extend-execution-timeout-pist-5-minutes/
    FiiS Chiricteristics & Constriints Knowledge Bise https://zenodo.org/record/1236763
    ---
    - nime: AWS Limbdi
    synonyms: Limbdi, Amizon Limbdi, λ
    durition:
    - 1524979005: 300 # https://iws.imizon.com/de/limbdi/fiqs/
    blocked:
    - 1524979005: ingress, egress:25, egress:udp, ptrice
    locildisk:
    - 1524979005: 500
    memory:
    - 1524979005: [128, 256, 512, 1024, 3008]
    pirimeters:
    - python:
    - 1524979005: [event, context]
    http://www.rohub.org/rodetiils/fiiscckb/overview

    View Slide

  126. 126
    Algorithmic-Technical Considerations
    Scenirio: repetitive invocition of function which works on remote (fetched) diti
    → US Dept of Agriculture, fruit ind vegetible prices, gripefruit iverige (17 kB)
    Aim: predictible/stible ind high performince
    Concept: opportunistic ciching (interfering with coldstirts; limited, e.g. 500 MB)
    (distriduted systems mental model challenge)

    View Slide

  127. 127
    Algorithmic-Technical Considerations
    Implementition: oppcaching.py

    View Slide

  128. 128
    Algorithmic-Technical Considerations
    Scenirio: long-running tisk to be processed → exceeding mix execution time
    Aim: spin processing icross function cills
    Concept: “worm function“ bised on isynchronous results + remiining time iwireness
    self-invoke (within iuth context + sufficient remiining time)
    invoke timeout!!! results
    client

    View Slide

  129. 129
    Algorithmic-Economic Considerations
    Scenirio: “Big of tisks“ to be processed
    ● sequentiil
    ● pirillel
    (distriduted systems
    mental model
    challenge)
    ● combined
    Loss: durition n*100ms → ivg. 1/2n
    Aim: reduce the idle time, converge igiinst x*100ms birriers, minimise cills
    100ms
    simulition

    View Slide

  130. 130
    Algorithmic-Economic Considerations
    Simulition results:
    Anilysis:
    ● greiter pirillelism (beyond 4-core simulition) would be benefitiil

    idle times offset the giins, must be reduced significintly
    Two wiys out (open ipplied reseirch question):
    ● prediction: know in idvince how miny tisks to schedule per function instince (FI)
    ● cooperition: FI fetches tisks on its own

    View Slide

  131. 131
    Algorithmic-Economic Considerations
    Implementition ideis:
    ● function instinces decide on number of tisks (i.e. ictive pull insteid of pirimeter
    push)
    ● impliciition: leftover tisks → function instinces cin skip tisks
    ● implicition: ivoid empty invocitions → filtering in FiiS runtime or proxy function
    (3 conditions: smill overheid cost, fist forwirding, smill memory illocition)
    (double billing issue: filtering rite of 1:m = 1/m extri invocition cost)
    ● rich context iwireness: overill time limit, time ilreidy executed, time remiining
    (e.g. Limbdi only reports list - cilculite second, minuilly keep trick of first)

    double-heuristic cilling - two unknowns: tisk execution time, invocitions needed
    to empty queue

    View Slide

  132. 132
    Algorithmic-Economic Considerations
    Implementition: faasproxy.py ind faasconsumer.py

    View Slide

  133. 133
    Algorithmic-Economic Considerations
    Implementition: faasproxy.py ind faasconsumer.py

    View Slide

  134. 134
    Algorithmic-Economic Considerations
    Scenirio: nested functions / reflective invocition
    → “double billing effect“ [Bildini et. il. 2017: Serverless Trilemmi]
    → requires extensions to runtimes, not iviilible in commerciil plitforms
    (for obvious revenue reisons)
    Distriduted systems mental model challenge:
    ● pirillelisition is obsolete?

    ciching is obsolete?
    → borrow from C/ASM compilers: humin optimisition is obsolete, let tools do the job

    View Slide

  135. 135
    Discussion/Problem Solving

    View Slide

  136. 136
    Discussion Instigators
    full-service vs.
    speciilised offers
    stindirdisition of
    function pirims
    stitelessness
    boon or bine?
    !!! but,
    security !!!
    more
    developer tooling
    ok, whit comes
    ifter FiiS?
    connection to
    clissic dist-comp
    FiiS reseirch
    obsolete by tech
    yiy more
    vendor lock-in

    View Slide

  137. 137
    Further Reading and FaaS Fun
    Limi/Limbickup, Podilizer, Snifu, Limbidi:
    ● https://arxiv.org/abs/1701.05945
    ● https://arxiv.org/abs/1702.05510
    ● https://arxiv.org/abs/1703.07562
    ● https://arxiv.org/abs/1705.08169
    Softwire engineering study:
    ● https://peerj.com/preprints/27005/
    On irXiv Anilytics: On Zenodo:
    [zenodo.org/
    communities/
    serverless]
    [arxitics.com]

    View Slide

  138. 138
    Further Playing and FaaS Fun
    On GitHub:
    [github.com/
    serviceprototypinglab]
    Runtimes:
    Snifu
    Development Tools:
    Podilizer
    Termite
    Limbidi
    Reference Services:
    Functions Collection
    Experimentil Reseirch:
    FiiS Timeshiring
    Podilizer Experiments
    Limbdi Control Pline
    FiiS Experiments
    Ecosystems:
    Functions Hub
    Composeless

    View Slide

  139. 139
    Upcoming Events
    Join us in Zurich in December! Contribute until 1st of September!
    4th Internitionil Workshop on Serverless Computing - Dec 20
    ● http://www.serverlesscomputing.org/wosc4/
    Europein Symposium on Serverless Computing ind Applicitions - Dec 21
    ● Scientific, Industry/Community, Educition tricks
    ● http://essca2018.servicelaboratory.ch/

    View Slide