Cloud Native OCI

Introduction

🖨️

Created with ❤ by Oracle A-Team

Workshop Goals

Explore Cloud Native services offered by OCI
Build and deploy polyglot microservices with OKE
Experience OCI services from within a single project
Provide reference implementations and sample code for real-world development

What is MuShop?

Cloud Native
Features
Basic Version
TL;DR

MuShop represents a showcase of many OCI Cloud Native services as a unified reference application
- An e-commerce reference app realized as a set of microservices developed on OCI
- Real use case scenarios for OKE, ATP, Streaming, Networking, and more
- Collection of self-paced, workshop-style exercises showcasing OCI features
```
helm install nginx-ingress \
          stable/nginx-ingress \
          --namespace nginx-ingress
```
```
oci lb load-balancer list | jq '.data[]'
```
```
kubectl create -f mushop.yaml
```
✅

ATP
Database

✅

OKE
Developer

✅

OCIR
Developer

✅

OCI Service Broker
Developer

✅

DNS Zone
Networking

✅

Object Storage
Core

✅

Streaming
Analytics

✅

Cloud Shell
Developer

✅

Load Balancer
Networking

✅

HealthCheck
Monitoring

✅

Metrics
Monitoring

✅

🆓

Always Free
Developer

✅

WAF
Security

✅

Terraform
IaC

✅

Resource Manager
IaC

✅

Functions
Developer

✅

API Gateway
Platform

✅

Email Delivery
Platform

✅

GraalVM
Developer

Planned

Events
Integration

Alarms
Monitoring

IDCS
Security

Key Management
Security

Data Flow
Big Data

Data Catalog
Big Data

Data Science
Big Data
Explore OCI with Resource Manager using the Always Free tier and a simplified deployment of the MuShop application
- A 3-tier reference app built to showcase the Oracle Cloud Infrastructure's Always Free tier
- Real world 3-tier architecture using Micro instances, ATP, Load Balancing and more
- Open Source and deployed as an Oracle Resource Manager Stack or Terraform configuration

Why Mu Shop?

MuShop is a polyglot microservices application purpose-built as a Cloud Native approach to OCI

MicroServices

Meow

What is Cloud Native?

Cloud native technologies are characterized by the use of containers, microservices, serverless functions, development pipelines, and infrastructure expressed as code. Cloud native enables faster software development and the ability to build applications that are resilient, manageable, observable, and dynamically scalable to global enterprise levels.

Platform Provisioning Orchestration Definition Observability

What is Cloud Native

anything that uses a cloud provider's api
APIs on top of resources eliminates middle men and human delay.
APIs can be invoked from an application - building applications that call these APIs to create resources - provision environments - are are the next logical step in infrastructure management.
Now that infrastructure can be orchestrated using application code, coding and SDLC principles can be applied to infra management - Infrastructure as code.
Moving up from infrastructure management to application development, we now can build applications that can leverage these mechanisms.
an application that can create more compute capacity when it requires it. (although this is better handled outside an application in many ways.)

Oracle Cloud Native

Application Development

Container Engine for Kubernetes (OKE) Enterprise-grade managed service to deploy containers

Cloud Infrastructure Registry (OCIR) Highly available service to distribute container images

Resource Manager Infrastructure as code for automated deployment

Functions Scalable, multitenant serverless functions

API Gateway Fully managed gateway for governed HTTP/S interfaces

Observability + Messaging

Monitoring Integrated metrics from all resources and services

Logging Highly scalable single pane of glass for resources and applications

Notifications Broadcast messages to distributed systems, like email & PagerDuty

Streaming Large scale data collection and processing

Events Handle infrastructure changes with functions, notifications and streaming

Application Development

Container Engine for Kubernetes (OKE) Enterprise-grade managed service to deploy containers

Cloud Infrastructure Registry (OCIR) Highly available service to distribute container images

Resource Manager Infrastructure as code for automated deployment

Functions Scalable, multitenant serverless functions

API Gateway Fully managed gateway for governed HTTP/S interfaces

Observability + Messaging

Monitoring Integrated metrics from all resources and services

Logging Highly scalable single pane of glass for resources and applications

Notifications Broadcast messages to distributed systems, like email & PagerDuty

Streaming Large scale data collection and processing

Events Handle infrastructure changes with functions, notifications and streaming

Cloud Native Landscape

Microservices

Benefits
Characteristics
Runtime
Patterns
Operating

- Modular service characteristics offer flexibility, scalability, and reduced development effort
- Enable distributed system design that can be realized as resilient, manageable and observable systems
- Application components can be built in different programming languages
- Each service owns its domain logic and communicates with others through simple protocols
- Services that can scale from inactivity to high volume and back again
- Each service can be independently deployed, updated, replaced, and scaled
- Event-driven architectures - Useful for scaling and designing with eventual consistency models
- Database Design - Logical Databases/ Shared databases/ CQRS / Saga Pattern.
- Cloud-based services allow businesses to pay only for the compute capacity they use
- Easier to implement automation at multiple levels in the application cycle and continuously deliver software to production

Benefits

the traditional deployment scenario and why thats broken
How micro services can address that
Its more chaotic, so how does it work -> (lots) automation and (some) good planning.

Characteristics

polygot
simple protocols for interoperability
do one thing but do it well.

Runtime

scalability
independent lifecycle.

Micro service patterns

Distributed system design

Operating

cost of ownership
ephemeral environments
continuous automation and delivery

The modern stack

Ephemeral resources managed via automation and cloud APIs
Decomposition of applications into microservices, running on container infrastructure
Developers and operations collaborating using DevOps methodologies

Pets Vs. Cattle

Pets: Servers or server pairs that are treated as indispensable or unique systems that can never be down. Typically they are manually built, managed, and “hand fed”.

Cattle: Arrays of more than two servers, that are built using automated tools, and are designed for failure, where no one, two, or even three servers are irreplaceable. Typically, during failure events no human intervention is required as the array exhibits attributes of “routing around failures” by restarting failed servers or replicating data.

See Pets vs. Cattle

Persistent Infrastructure has a high overhead compared to Ephemeral Infrastructure