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
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. @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. @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. @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. @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. @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. @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
12. @DanielKrookOpenWhisk.org
Join us to build a cloud native platform for the future!
OpenWhisk.org
dwopen.slack.com #openwhisk
developer.ibm.com/open
Notas del editor
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