Cloud Native Architectures with an Open Source, Event Driven, Serverless Platform

816 views

Published on

IBM keynote at CloudNativeCon / KubeCon in Seattle, Washington on November 8, 2016.
https://cnkc16.sched.org/event/8K4c

New cloud programming models enabled by serverless architectures are emerging, allowing developers to focus more sharply on creating their applications and less on managing their infrastructure. The OpenWhisk project started by IBM provides an open source platform to enable these cloud native, event driven applications.

Daniel Krook, Senior Software Engineer, IBM

Published in: Software
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
816
On SlideShare
0
From Embeds
0
Number of Embeds
4
Actions
Shares
0
Downloads
9
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide
  • Hello, my name is Daniel Krook, I’m a Senior Software Engineer at IBM. Today I’m going to tell you about an emerging programming model called serverless computing.
  • Serverless architectures are gaining interest from many developers and organization because they promise to provide better technical and business benefits over existing compute models.
  • New serverless platforms allow developers to focus more on their key business logic, rather than the infrastructure, hence the name because the point of view and concerns have shifted.


    ===

    Over the past ten years we’ve seen a steady improvement how fast developers can create and deploy applications to production.

    Starting with the moment that service providers matched virtualized resources with self service APIs, speed has been accelerating.

    Recently we’ve seen the shift from IaaS to PaaS, where developers concern themselves only with their apps and data.

    And now, we’ve seen the rise of Functions as a Service programming.

    Thoughout this shift the developer has narrowed his focus purely on business value, and lost site of more and more operational concerns, hence the term serverless.

  • The technical capabilities of these new platforms promise to help developers build well designed cloud native applications more easily by offloading many operational concerns recommended by the 12 Factors.


    ===

    Beyond those deployment problems, this new model improves cloud native development as it promises to address many if not most of the good design patterns provided in the 12 Factors.

    In fact, what is not directly related to code is now covered by serverless platforms like OpenWhisk.

  • Many new types of event driven applications that aren't traditional web apps want to leverage the benefits of cloud computing. They are a good fit for the event driven model that serverless architectures support using different protocols.


    ===

    Another trend driving new models of cloud native application development has been the trend towards less web application focused services as cloud computing matches more and more types of workloads.

    With them come a need for event driven programming models.
  • At the business level a new cost model is also emerging, tying code execution time directly to the billing for resources used. While serverless architectures aren’t a silver bullet, they do provide a new deployment option.


    ===

    Serverless billing models promises an even closer match between business value gained and computing resources used.
  • All of these factors come together to drive interest in serverless architectures and platforms for event driven programming.


    ===

    So, to summarize these technology improvements and solutions combined an efficient pricing model are driving interest in severless, event driven computing.
  • OpenWhisk, an open source platform started by IBM provides an open source platform for serverless applications. It’s flexible, extensible, and integrates with a variety of event sources.


    ===

    OpenWhisk provides a similar set of functionality to hosted services from Amazon, Google, and Microsoft, but it also adds unique features in a simple to extend polyglot model, open source nature, and ability to be deployed into many types of environments.
  • It offers the developer - the person with the serverless point of view - a straight forward programming model based on 4 concepts: triggers, actions, rules, and packages.


    ===

    Let’s talk in a bit more detail about the programming model. There are four main entities in OW: triggers, actions, rules, and packages
  • You can get started with OpenWhisk as hosted on Bluemix as a beta service. It provides an web UI, online editor, and visual monitoring console over and above the open source platform.
  • OpenWhiks is built on top of proven, cloud native open source technology such as NGINX, Consul, CouchDB and Docker. You can develop with the open source platform using Vagrant on a workstation or deploy it on top of OpenStack.


    ===

    Docker is used to setup a new self-encapsulated environment (called container) for each action that we invoke in a fast, isolated and controlled way. In a nutshell, for each action invocation a Docker container is spawned, the action code gets injected, it gets executed using the parameters passed to it, the result is obtained, the container gets destroyed.
  • If you’re interested in building a cloud native platform for the future of serverless apps, join the growing community at OpenWhisk.org
  • Cloud Native Architectures with an Open Source, Event Driven, Serverless Platform

    1. 1. Cloud native architectures with an open source, event driven, serverless platform Daniel Krook, Senior Software Engineer, IBM
    2. 2. @DanielKrookOpenWhisk.org Serverless architectures are drawing interest due to a combination of compelling technical and business factors
    3. 3. @DanielKrookOpenWhisk.org With serverless developers focus more on code, less on infrastructure Bare metal Virtual machines Containers Functions Decreasing concern (and control) over stack implementation Increasingfocusonbusinesslogic
    4. 4. @DanielKrookOpenWhisk.org Serverless platforms can address 12 Factors for developers I Codebase Handled by developer (Manage versioning of functions themeselves) II Dependencies Handled by developer, facilitated by serverless platform (Runtimes and packages) III Config Handled by platform (Environment variables or injected event parameters) IV Backing services Handled by platform (Connection information injected as event parameters) V Build, release, run Handled by platform (Deployed resources immutable and internally versioned) VI Processes Handled by platform (Single stateless containers used) VII Port binding Handled by platform (Actions or functions automatically discovered) VIII Concurrency Handled by platform (Process model hidden and scales in response to demand) IX Disposability Handled by platform (Lifecycle hidden from user, fast startup and elastic scale prioritized) X Dev/prod parity Handled by developer (Developer is deployer. Scope of what differs narrower) XI Logs Handled by platform (Developer writes to console.log, platform streams logs) XII Admin processes Handled by developer (No distinction between one off processes and long running)
    5. 5. @DanielKrookOpenWhisk.org Emerging workloads are a good fit for event driven programming Execute app logic in response to database change Perform edge analytics in response to sensor input Provide cognitive computing via a conversational bot Schedule tasks according to a specific timetable Invoke autoscaled mobile backend services
    6. 6. @DanielKrookOpenWhisk.org New cost models can more accurately charge for compute time Applications billed by compute time (millisecond) rather than reserved memory (GB/hour). While many applications must still be deployed in an always on model, serverless architectures provide an alternative that can result in substantial cost savings for a variety of event driven workloads. Means a greater linkage between cloud resources used and business operations executed.
    7. 7. @DanielKrookOpenWhisk.org Technological and business factors make serverless compelling Serverless architectures are gaining traction Cost models getting more granular and efficient Growth of event driven workloads that need automated scale Platforms evolving to facilitate cloud native design for developers
    8. 8. @DanielKrookOpenWhisk.org OpenWhisk enables these serverless, event-driven workloads Serverless deployment and operations model Optimized utilization, fine grained metering at any scale Flexible, extensible, polyglot programming model Open source and open ecosystem (Apache proposal) Ability to run in public, private, and hybrid models OpenWhisk a cloud platform that executes code in response to events
    9. 9. @DanielKrookOpenWhisk.org Developers work with triggers, actions, rules, and packages Data sources define events they emit as Triggers. Developers map Actions to Triggers via Rules. Packages provide integration with external services. T A P R
    10. 10. @DanielKrookOpenWhisk.org Try OpenWhisk on IBM Bluemix bluemix.net
    11. 11. @DanielKrookOpenWhisk.org OpenWhisk is built on solid open source foundations bit.ly/ow-int
    12. 12. @DanielKrookOpenWhisk.org Join us to build a cloud native platform for the future! OpenWhisk.org dwopen.slack.com #openwhisk developer.ibm.com/open

    ×