Containers & Microservices For Realists

Karthik Gaekwad @iteration1

Oracle Code 2017- New York

• 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

Audience Survey

Overview• The Evolution of DevOps

• Rise of Microservices, Containers applications

• What are they?

• Why should you care?

• What are they used for?

• What’s Oracle doing in this space?

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

Evolution of Devops

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 and 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 configurations are fed in the

same way to each container which reduces configuration 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 configuration 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)

Real World Examples

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)

Standardization Example• 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)

Standardization Example• 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 Pipelinecreate a

dockerfile

CI/CD Pipelinecreate a

dockerfileCommit code

to source control

CI/CD Pipelinecreate a

dockerfileCommit code

to source control

Build triggered in CI system

CI/CD Pipelinecreate a

dockerfileCommit code

to source control

Build triggered in CI system

Build container

image

CI/CD Pipelinecreate a

dockerfileCommit code

to source control

Build triggered in CI system

Build & Test container

image

Push to docker registry

Completed CI!

CI/CD Pipelinecreate a

dockerfileCommit code

to source control

Build triggered in CI system

Build & Test container

image

Push to docker registry

Webhook trigger to

Orchestrator

CI/CD Pipelinecreate a

dockerfileCommit 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://flux7.com/docker/

Container Management Trends

Container Orchestration

Container Orchestration

Container Orchestration• Major Players:

• Nomad

• Docker Swarm

• Kubernetes

• Mesos + Marathon

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

Container Orchestration

• My Opinions:

• Don’t build your own

• What are your infrastructure goals?

• Consider team size and strength of team

Orchestration

Source: devops.com and clusterHQ survey 2016

Things we are doing at Oracle

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

Things we are doing at Oracle

• Container Registry

• Contains pre built Oracle images

• https://container-registry.oracle.com/

• Docker 101 tutorial: https://github.com/mikeraab/docker001

Things we are doing at 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

Things we are doing at 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

Things we are doing at Oracle

• Free $300 credits to try out all the different services:

• https://cloud.oracle.com/en_US/tryit

Loved it? Hated it? Send me feedback:

@iteration1karthik.gaekwad@oracle.com

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/

BonusSlides

Serverless Applications

Serverless Applications

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 ApplicationsApplications 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 ArchitectureClient (Browser)

Load Balancer

Load BalancerLoad Balancer

Server

Database

Serverless ArchitectureClient (Browser)

Auth Service Web DeliveryAPI Gateway

Database

Function B

Function A

Function C

Difference from PaaS?

• 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 efficient code

Difference from PaaS?

Difference from containers?• FaaS is typically built with containers…

• Once again..Scaling is the core difference.

• Managed, transparent, fine 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