Containers, microservices and serverless for realists

Containers, Microservices &
Serverless for Realists
Karthik Gaekwad
@iteration1
Keep Austin Agile 2017

• Principal Member of Technical Staff
• Oracle Container Cloud Team
• Previous:
• 10 years building cloud products
• Enterprise/Startup experience
Karthik Gaekwad
@iteration1

• Community Involvement:
• Devopsdays Core Organizer
• Container Days Core Organizer
• Cloud Austin
• Docker Austin meetup
• The most popular docker helloworld
image: dockerhub.com/karthequian/
helloworld
Karthik Gaekwad
@iteration1

Overview
• The Evolution of DevOps
• Rise of Microservices, Containers,
Serverless applications
• What are they?
• Why should you care?
• What are they used for?

Evolution of Devops
• Devops at least officially 8 years old
• Velocity 2009:
• 10 Deploys a day at flickr by John Allspaw, Paul
Hammond
• Agile Infrastructure openspace: Andrew Shaefer &
Patrick Debois
• 2009: 1st Devopsdays conference, Ghent
• Today: ~150 official devopsdays conference

CULTURE
MEASUREMENT
AUTOMATION
SHARING
Evolution of Devops
John Willis
Damon Edwards
By:

Evolution of Devops
“System administrators participating in an
agile development process alongside
developers and using many of the same agile
techniques for their systems work.”
The Agile Admin Blog
Well Defined:

Evolution of Devops
• Training classes available:
• Devops Fundamental Course (Ernest Mueller,
James Wickett)
• Certifications available:
• AWS Certified Devops Engineer
• RedHat Certified Devops Architect
• Devops Foundations by the Devops institute

Containers & Microservices
…The next phase of Devops

Containers & Microservices
• Containers and Micro services fit the
devops paradigm!
• Microservices allows developers to build
applications in modular way
• Allows for containerization
• Containerization allows for collaboration
between dev and ops
• Common language spoken between 2
teams in an org

Microservices
“Independent processes
communicating with each other
with well defined API’s to form
larger more complex
applications”

Microservices
• Do one thing, and do it well (fine
grained)
• Independently built- common
language to communicate
• Independently deployable
• Fault tolerant and reliable
• Based on 12 factor app principles

12 Factor App
•Use declarative formats for setup automation;
minimize time and cost for new developers joining
the project
•Clean contract with the underlying OS, offering
maximum portability between execution
environments;
•Suitable for deployment on modern cloud platforms
•Minimize divergence between development and
production- enabling continuous deployment
•Scale up without significant changes to tooling,
architecture, or development practices.

Relationship with containers
• Microservices + containers are a great
fit
• Single service on a container:
• Isolates service and makes it easy to
manage and debug
• Best practice for new architectures with
containers
• Consider building your architecture in
this manner

Containerization
• Strong collaboration between dev and
ops.
• Initially championed by developers,
and now well liked by operations as
well.

Trends
• 2 great surveys:
• Datadog docker adoption: https://
www.datadoghq.com/docker-adoption/
• devops.com & ClusterHQ survey:
https://clusterhq.com/assets/pdfs/
state-of-container-usage-june-2016.pdf

Source: devops.com and clusterHQ survey 2016

2016: 10.8% of all Datadog customers use Docker (up from
8.2% in 2015)

10% of all hosts monitored by Datadog have Docker
running on them

Fundamentals
• Portability
• Standardized Environments
• Scaling
• Continuous Delivery
• Dependency Management

Portability
•Idea of writing once and running anywhere.
•As long as your application is Dockerized,
you can run it anywhere that has the
Docker Engine installed.
•Easy to change from 1 host to another.
•Flexibility to change underlying
infrastructure/operating systems etc.
•Change from 1 cloud provider to another.

Standardization
• Coding environments can be made consistent
from development ->staging->QA->production.
• Per environment conﬁgurations are fed in the
same way to each container which reduces
conﬁguration issues.
• Time spent debugging environmental issues is
reduced drastically.
• Developers understand the production
environment better, which leads to better code
quality.

Scaling
•Containers take seconds to deploy.
•Scale up and down your infrastructure
is a lot faster than traditional
conﬁguration management tools.

Continuous Delivery
•Docker API’s and Docker Hub make it
easy to build a deployment pipeline.
•After successful builds, a CI system
can build and push a Docker image to
the Hub/private Docker repo.
•Deploy new containers to desired
environment on a periodic basis/trigger
webhooks to deploy.

Dependency Management
• Dependency hell happens when:
• 2 running Java or Ruby applications that depend on
different versions of the same library…..
• How Docker can help:
• Isolate each application (along with it’s
dependencies) so that they can be loaded in their
own container.
• 1 container for 1 application or service (micro service
architecture)

Standardization
Take existing (or new) applications,
containerize them, run them the same
way on dev/stage/production.

Standardization
• Typical Pattern:
• Infrastructure/Applications run in containers.
• Every code push builds a new image for the
application.
• All environments uses the same command to
run the application:
• sudo docker run -d -p 7777:7777 -e
SE_DB=‘db_val’ karthequian/helloworld

Standardization Example
• Write service RFC (Request for Comments)
• Wait for feedback
• Scaffolding work + Develop service
• Wait for infrastructure team to write service scaffolding
• Wait for infrastructure team to provision services
• Deploy to development servers and test
• Deploy to production
• Monitor, iterate
• Uber (In the past)

• Write service RFC (Request for Comments)
• Wait for feedback
• Scaffolding work + Develop service
• Build containers for service
• Wait for infrastructure team to deploy containers to
development servers
• Deploy to development servers and test
• Deploy to production
• Monitor, iterate
• Uber (With Docker)

• Implementing Docker got rid of:
• Wait for the infrastructure team to write service
scaffolding
• Wait for infrastructure team to provision
services
• Ops doesn’t rely on playbooks, but rather, just
deploy existing container images
• No fear of one set of dependencies for one app,
breaking another app
• Uber (With Docker)

CI/CD Pipeline
Most common usecase of how teams
use Docker

CI/CD Pipeline
create a
dockerﬁle

CI/CD Pipeline
create a
dockerﬁle
Commit code
to source
control

CI/CD Pipeline
create a
dockerﬁle
Commit code
to source
control
Build
triggered in
CI system

CI/CD Pipeline
create a
dockerﬁle
Commit code
to source
control
Build
triggered in
CI system
Build
container
image

CI/CD Pipeline
create a
dockerﬁle
Commit code
to source
control
Build
triggered in
CI system
Build & Test
container
image
Push to
docker
registry
Completed CI!

CI/CD Pipeline
create a
dockerﬁle
Commit code
to source
control
Build
triggered in
CI system
Build & Test
container
image
Push to
docker
registry
Webhook
trigger to
Orchestrator

CI/CD Pipeline
create a
dockerﬁle
Commit code
to source
control
Build
triggered in
CI system
Build & Test
container
image
Push to
docker
registry
Webhook
trigger to
Orchestrator
New
containers
online!
Completed CD!

Other Usecases
•Hosting Legacy Applications
•Running a PaaS/ Datacenter using Docker.
•EngineYard/Yandex/Baidu are great examples of
this.
•Containerizing hard to run applications is becoming
a frequent usecase.
•Single->multi tenant apps: http://ﬂux7.com/docker/

Container Orchestration
• Methodologies:
• Nomad
• Docker Swarm
• Kubernetes
• Mesos + Marathon
• Custom!

• Compare & contrast: http://
blog.gingergeek.com/tag/
orchestration/ via @lcalcote

Orchestration
Source: devops.com and clusterHQ survey 2016

• My Opinions:
• Don’t build your own
• What are your infrastructure
goals?
• Consider team size and strength
of team

Serverless Applications
• First used to describe applications that
depended on 3rd party applications / services
(‘in the cloud’) to manage server-side logic and
state
• “Backend as a service applications”

Serverless Applications
Applications where some amount of server-side logic
is still written by the application developer
Unlike traditional architectures is run in stateless
compute containers that are event-triggered,
ephemeral (may only last for one invocation), and
fully managed by a 3rd party.
One way to think of this is “Functions as a service”.
AWS Lambda, Azure functions- most popular
implementations, but there are others.

Traditional Architecture
Client (Browser)
Load Balancer
Load Balancer
Load Balancer
Server
Database

Serverless Architecture
Client (Browser)
Auth Service Web DeliveryAPI Gateway
Database
Function B
Function A
Function C

• Way to code microservices does not change: 12
factor app mindset
• You still have to think of scaling in PaaS:
• “How many dynos do I need in Heroku to run this
app?”
• “How long does it take to scale from 2->4 servers?”
• Auto scaling on PaaS is great, but this is on a request
basis
• Forces developers to write cleaner, more efﬁcient
code
Difference from PaaS?

Difference from containers?
• FaaS is typically built with containers…
• Once again..Scaling is the core difference.
• Managed, transparent, ﬁne grained.
• Need to invest time in container platforms
to perform scaling actions.
• Prediction: may not be true a year from
now…

Serverless Use Cases
• Image Processing
• Data Transformation
• Log Analysis
• Authentication, Licensing

Loved it? Hated it?
Send me feedback:
@iteration1

Attributions
• Images: https://unsplash.com and https://pixabay.com
• State of devops whitepaper: https://puppet.com/resources/infographic/2016-state-of-devops-report-infographic
• Datadog docker adoption: https://www.datadoghq.com/docker-adoption/
• devops.com & ClusterHQ survey: https://clusterhq.com/assets/pdfs/state-of-container-usage-june-2016.pdf
• Oracle Docker Images: https://github.com/oracle/docker-images
• Oracle Container Cloud Service: cloud.oracle.com/container
• Oracle Application Container Service: https://cloud.oracle.com/en_US/application-container-cloud
• Microservices: https://martinfowler.com/articles/microservices.html
• 12 factor apps: https://12factor.net/
• Serverless: https://martinfowler.com/articles/serverless.html
• Legacy apps at Uber: https://thenewstack.io/docker-helped-turbocharge-ubers-deployments/
• @lcalcote: https://twitter.com/lcalcote/status/767744030436315136
• Uber story: https://thenewstack.io/docker-helped-turbocharge-ubers-deployments/
• Unikernels Paper: http://unikernel.org/ﬁles/2014-cacm-unikernels.pdf

Unikernels
Unikernels are specialised, single-
address-space machine images
constructed by using library operating
systems.

Unikernel beneﬁts
• Tiny footprint compared to regular
application.
• Reduced Attack Surface == Improved
Security.
• Optimized.
• Fast boot.
• http://unikernel.org/ﬁles/2014-cacm-unikernels.pdf

Things we are doing at
Oracle
• Dockerfiles: https://github.com/oracle/docker-
images
• Weblogic: https://github.com/oracle/docker-
images/tree/master/OracleWebLogic/
dockerfiles/12.2.1.1
• DB: https://github.com/oracle/docker-images/
tree/master/OracleDatabase/dockerfiles
• Also for Dockerfiles for: Java, OpenJDK,
Coherance, MySQL etc

Oracle
• Container Registry
• Contains pre built Oracle images
• https://container-
registry.oracle.com/
• Docker 101 tutorial: https://
github.com/mikeraab/docker001

Oracle
• Container Products for Oracle Public Cloud:
• Oracle Application Container Cloud
• Great for Java/Node/PHP applications
• Oracle Container Service
• Bring your own containers
• Container Management solution

Oracle
• OCCS Stacks:
• ElasticSearch, Kibana, Logstash (ELK): https://github.com/
oracle/docker-images/tree/master/ContainerCloud/stacks/
elk
• Kafka microservices on OCCS: https://
community.oracle.com/community/cloud_computing/oracle-
cloud-developer-solutions/blog/2017/03/20/running-docker-
based-kafka-streams-microservices-on-oracle-container-
cloud
• https://community.oracle.com/community/cloud_computing/
infrastructure-as-a-service-iaas/oracle-container-cloud-service

Oracle
• Free $300 credits to try out all the
different services:
• https://cloud.oracle.com/en_US/tryit

Containers, microservices and serverless for realists

Containers, microservices and serverless for realists

More Related Content

What's hot

Similar to Containers, microservices and serverless for realists

More from Karthik Gaekwad

Recently uploaded

Containers, microservices and serverless for realists