My talk at Capgemini Tech Talk SE in Wroclaw on 01.03.2019

2. Serverless Java on Kubernetes
Krzysztof Sobkowiak (@ksobkowiak)
https://blog.cdemi.io/what-is-serverless-architecture/
Wrocław, 01.03.2019
#TechTalkSE

3. About me
● Capgemini
○ Senior Delivery Architect, Trainer
○ JEE & OSS solutions, system integration, cloud, microservices,
devops
● Apache Software Foundation
○ Member
○ Apache ServiceMix Committer & PMC Chair (V.P. ServiceMix)
○ Contributor @ Apache Karaf, Apache CXF, Apache Camel,
Apache ActiveMQ
● Co-organizer of #geekweekwro
Views in this presentation are my personal views and do not necessarily reflect the views of Capgemini or The Apache Software Foundation.

4. https://wspolczesna.pl/koniec-swiata-1-lutego-asteroida-2002-nt7-uderzy-w-ziemie-jasnowidz-z-czluchowa-komentuje-01022019/ar/13852986

5. Monolith
http://bit.ly/serverlessjavajbcn

6. Microservices
http://bit.ly/serverlessjavajbcn

7. https://redmonk.com/jgovernor/2016/10/12/when-web-companies-grow-up-they-turn-into-java-shops/

8. https://redmonk.com/sogrady/2018/08/10/language-rankings-6-18/

9. Functions
http://bit.ly/serverlessjavajbcn

10. What is serverless?
“Serverless computing refers to the concept of building and
running applications that do not require server management.
It describes a finer-grained deployment model where
applications, bundled as one or more functions, are uploaded
to a platform and then executed, scaled, and billed in
response to the exact demand needed at the moment.”
https://www.cncf.io/blog/2018/02/14/cncf-takes-first-step-towards-serverless-computing/

11. What is serverless?
“Serverless architectures are application designs that
incorporate third-party “Backend as a Service” (BaaS)
services, and/or that include custom code run in managed,
ephemeral containers on a “Functions as a Service” (FaaS)
platform.”
https://martinfowler.com/articles/serverless.html

12. Function as a Service (FaaS)
● Function
○ Small bits of code with a well defined job
○ Easy to understand and maintain
● As a service
○ The system takes care of provisioning, scaling, patching, …
○ Each function can scale independently
fx

13. https://serverless.com/blog/serverless-by-the-numbers-2018-data-report/

14. https://serverless.com/blog/serverless-by-the-numbers-2018-data-report/

16. FaaS Kubernetes & Java support

17. Apache OpenWhisk
https://openwhisk.apache.org/

18. Integrate with many popular services
https://openwhisk.apache.org/

19. Deploys anywhere
https://openwhisk.apache.org/

20. How does it work?
https://medium.com/openwhisk/uncovering-the-magic-how-serverless-platforms-really-work-3cb127b05f71

21. OpenWhisk & Containers
wsk action invoke docker run
≈

22. OpenWhisk & Containers
Start container
docker run
Initialize
/init
Run
/run
https://medium.com/openwhisk/squeezing-the-milliseconds-how-to-make-serverless-platforms-blazing-fast-aea0e9951bd0

23. OpenWhisk & Containers
cold
Start container
docker run
Initialize
/init
Run
/run
https://medium.com/openwhisk/squeezing-the-milliseconds-how-to-make-serverless-platforms-blazing-fast-aea0e9951bd0

24. OpenWhisk & Containers
cold pre-warmed, paused
Start container
docker run
Initialize
/init
Run
/run
https://medium.com/openwhisk/squeezing-the-milliseconds-how-to-make-serverless-platforms-blazing-fast-aea0e9951bd0

25. OpenWhisk & Containers
cold pre-warmed, paused hot
Start container
docker run
Initialize
/init
Run
/run
https://medium.com/openwhisk/squeezing-the-milliseconds-how-to-make-serverless-platforms-blazing-fast-aea0e9951bd0

26. OpenWhisk & Containers
cold pre-warmed, paused hot
Start container
docker run
Initialize
/init
Run
/run
fasterhttps://medium.com/openwhisk/squeezing-the-milliseconds-how-to-make-serverless-platforms-blazing-fast-aea0e9951bd0

27. Programming model
JSON
Trigger
FeedEvent source
Rule
Action

28. ● Basic unit of work
● A stateless, relatively short-running function
● Invoked as an event handler.
● Invoking an action generates an "activation id",
used to retrieve results
Action
JSONJSON

29. Supported languages
https://openwhisk.apache.org/

30. Action - JavaScript
function main(params) {
return { payload: 'Hello ' + params.body.text +
' from JavaScript action on OpenWhisk on OpenShift '};
}

31. Creating an action
To create an action, we need to we need to give it a name and configure it in
OpenWhisk
$ wsk -i action create msgaction msgaction.js

32. Invoking an action
Once it has a name, it can be invoked directly:
$ wsk -i action invoke msgaction --param body '{"text":"Tech Talk SE"}' --result
{ "payload": "Hello Tech Talk SE from JavaScript action on OpenWhisk on OpenShift" }
$ wsk -i activation get -l # see the details, logs

33. Action - Python
def main(params):
return { "payload" :
"Hello " + str(params["body"]["text"]) +
" from Python action on OpenWhisk on OpenShift"}

34. Updating an action
$ wsk -i action update msgaction msgaction.py
$ wsk -i action invoke msgaction --param body '{"text":"Tech Talk SE"}' --result
{ "payload": "Hello Tech Talk SE from Python action on OpenWhisk on OpenShift" }

35. Creating an action
packages:
demo:
actions:
msgaction:
function: msgaction.js
$ wskdeploy -m manifest-msgaction.yml

36. ● Wide choice of good tooling
● “Plain old Java”
● Ability to build complex applications
● Low latency/high performance
● Serverless JVM
Blueprints for Serverless Java

37. Action - Java (POF)
public static JsonObject main(JsonObject params) {
JsonObject response = new JsonObject();
response.addProperty("payload", "Hello " +
params.getAsJsonObject("body").get("text").getAsString() +
" from Java action on OpenWhisk on OpenShift " );
return response;
}

38. Action - Java
$ wsk -i action update msgaction target/msgaction.jar --main com.example.FunctionMain
$ wsk -i action invoke msgaction --param body '{"text":"Tech Talk SE"}' --result
{ "payload": "Hello Tech Talk SE from Java action on OpenWhisk on OpenShift" }
$ mvn clean package

39. Spring Cloud Functions (SCF)
Spring Boot
Spring Cloud Function
Web
Spring Cloud Function
Webflux
Spring Cloud Stream
HTTP Message

40. Serverless Platforms Adapters
FaaS Provides
Spring Cloud Function Adapter
HTTP Message

41. Spring Cloud Functions (SCF)
@SpringBootApplication
public class Application {
@Bean
public Function<Flux<String>, Flux<String>> uppercase() {
return flux -> flux.map(value -> value.toUpperCase());
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

42. ● Wide choice of good tooling → Maven, Gradle, IDE,...
● “Plain old Java” → POF
● Ability to build complex applications → SCF
● Low latency/high performance →pre-warmed containers,
OpenJ9, CDS, AOT
● Serverless JVM → OpenJ9
Blueprints for Serverless Java

43. Demo - Java Action
bit.ly/faas-tutorial

44. Serverless Microservices - web actions & api gateway
● Actions invoked via urls using HTTP
verbs like GET, POST, PUT, …
● Automatic content detection via
prefixing
● Api Gateway - proxy to Web Actions
○ HTTP method routing
○ client id/secrets
○ rate limiting
○ CORS
https://github.com/rabbah/wsk-qr

45. Web Actions & API Gateway
$ wsk -i action create fibonacci fibonacci.js --web true
$ WEB_URL=`wsk -i action get --url fibonacci | awk 'FNR==2{print $1}'`
$ curl -k $WEB_URL.json?num=5
$ wsk -i api create /fibonacci get fibonacci
$ curl -X GET ${API_URL}/api/${GENERATED_API_ID}/fibonacci?num=5

46. API Gateway
wsk api create -n "Book Club" /club /books/{isbn} get getBooks
wsk api create /club /books get getBooks
wsk api create /club /books post postBooks
wsk api create /club /books/{isbn} put putBooks
wsk api create /club /books/{isbn} delete deleteBooks

47. Demo - Web Action

48. Action Composition
https://openwhisk.apache.org/
● Pre-defined chain of actions
○ Sequences
● Determined dynamically
○ Conductors
○ Composer
● Output of previous step is input
of the next one
● Only first function in Sequence
can accept parameter

49. Action Sequence
$ wsk action create mySequence
--sequence /whisk.system/utils/split,/whisk.system/utils/sort
$ wsk action invoke
--result mySequence
--param payload "Java,Python,Swift,JavaScript,Ruby,C"
--param separator ','

50. Demo - Action Chaining

51. Event Driven Capabilities
● Triggers are channels for events
● Triggers can be linked, via rules, to one or more actions
● Events could be
○ Another function
○ External event source called as Feed Provider
● Trigger can be registered to Event Provider via Feeds (Stream of Events)
○ Feed can be:
■ Polling
■ Webhook
■ Persistent Connection JSON

52. Trigger & Rules
$ wsk -i trigger create every-5-seconds
--feed /whisk.system/alarms/alarm
--param cron '*/5 * * * * *'
--param maxTriggers 25
--param trigger_payload "{"name":"Tech Talk SE","place":"Wroclaw"}"
$ wsk -i rule create invoke-periodically
every-5-seconds
/whisk.system/samples/greeting
$ wsk -i activation poll

53. Demo - Triggers & Rules

54. Knative

55. Knative & OpenWhisk
Kubernetes
Foundational container scheduling and infrastructure management
Cluster Management Capacity Management Network Management Consistent & repeatable deployment
OpenWhisk
Serverless abstractions (actions, triggers, rules, etc) & multi-tenancy
Higher level abstractions (action, trigger, rule) API gateway & management
CLI & dev tools
Multi-tenancy
High level control flow logic
Throttles Web Actions
Autoscaling Eventing Routing Code → Container conversion
Serverless infrastructure building blocks & routing
Knative
https://www.ibm.com/blogs/cloud-computing/2018/07/24/ibm-cloud-google-knative-serverless/

56. thanks!
@ksobkowiakkrzysztof.sobkowiak@capgemini.com
http://bit.ly/serverlessjava-ttse

57. Credits
Special thanks to all the people who made and released their awesome resources
for free:
● Serverless Java: Challenges and Triumphs by David Delabassee
● Serverless Java on Kubernetes by Burr Sutter and Rafael Benevides
● Functions as a Service with Apache OpenWhisk and Openshift by Brendan
McAdams
● Your Journey into the Serverless World by Kamesh Sampath