The document discusses developer workflows for building cloud applications using containers, functions, and managed cloud services. It presents options for developing applications locally and deploying to the cloud using tools like Docker Desktop, Azure Functions runtime, Azure Dev Spaces, and Telepresence that enable local development and debugging. The document also discusses approaches for packaging and deploying distributed applications using CNAB and Duffle.
20. Docker is building a stack to program the Internet
CE
EEA commercial product,
built on
a development platform,
built on
infrastructure,
built on
standards.
21. The elements of orchestration
Scheduling Affinity/anti-
affinity
Health
monitoring
Failover
Scaling Networking Service
discovery
Coordinated
app upgrades
22. Deploy your
applications quickly
and predictably
Scale your
applications on
the fly
Roll out
new features
seamlessly
Limit hardware
usage to required
resources only
Portable
Public, private, hybrid,
multi-cloud
Extensible
Modular, pluggable,
hookable, composable
Self-healing
Auto-placement, auto-restart,
auto-replication, auto-scaling
Kubernetes: empowering you to do more
25. Containers in Azure
Choice of developer tools and clients
Azure Container Registry Docker Hub
App Service
Deploy web apps or
APIs using
containers in a PaaS
environment
Service Fabric
Modernize .NET
applications to
microservices using
Windows Server
containers
Kubernetes Service Container Instance
Scale and orchestrate
Linux containers using
Kubernetes
Ecosystem
Bring your Partner
solutions that run
great on Azure
Elastically burst from
your Azure Kubernetes
Service (AKS) cluster
26. If you have a preferred container platform
Pivotal Cloud Foundry Kubernetes Docker Enterprise Edition
Red Hat OpenShift Mesosphere DC/OS
You could bring that platform to Azure
Self-managed
Kubernetes
Pivotal Cloud Foundry Docker Enterprise
Edition
Red Hat OpenShift Mesosphere DC/OS
Flexibility Productivity Trust
27. Azure Kubernetes
Service (AKS)
Azure Container
Instances (ACI)
Azure Container
Registry (ACR)
Azure Kubernetes Service (AKS)
Simplify the deployment, management, and operations of Kubernetes
Service Fabric
App Service
Azure Batch
Deploy and manage
Kubernetes with
ease
Scale and run
applications with
confidence
Secure your Kubernetes
environment
Accelerate
containerized application
development
Work how you want
with open-source tools
& APIs
Set up
CI/CD in a
few clicks
29. Get started easily
$ az aks create -g myResourceGroup -n myCluster --generate-ssh-keys
Running ..
$ az aks install-cli
Downloading client to /usr/local/bin/kubectl ..
$ az aks get-credentials -g myResourceGroup -n myCluster
Merged "myCluster" as current context ..
$ kubectl get nodes
NAME STATUS AGE VERSION
aks-nodepool1-29486530-0 Ready 4m v1.11.9
aks-nodepool1-29486530-1 Ready 4m v1.11.9
aks-nodepool1-29486530-2 Ready 4m v1.11.9
Azure Kubernetes Service (AKS)
30. Increase agility with
containers on
demand
Secure applications
with hypervisor
isolation
Run containers
without managing
servers
Azure Container Instances (ACI)
Easily run containers on Azure without managing servers
Azure Kubernetes
Service (AKS)
Azure Container
Instances (ACI)
Azure Container
Registry (ACR)
Service Fabric
App Service
Azure Batch
34. Virtual Nodes
• Seamlessly connect AKS to extra burst
capacity within ACI
• Little to no operational overhead
• Eliminates the need to over provision
clusters
• Service discovery & bring your own
virtual network
• We develop in the open through
Virtual Kubelet
Public preview
36. Use Azure Managed Data Platform Services
AZURE SEARCH
AZURE
DATA CATALOG
AZURE STORAGE
BLOBS
AZURE DATA LAKE
STORE
AZURE SQL DATA
WAREHOUSE AZURE SQL DB AZURE COSMOS DB
AZURE
ANALYSIS SERVICES
POWER BI
AZURE DATA LAKE
ANALYTICS
AZURE
HDINSIGHT
AZURE
DATABRICKS
AZURE
STREAM ANALYTICS
AZURE ML ML SERVER
AZURE MySQL DB AZURE PostgreSQL
DB
REDIS CACHE
37. Open Service Broker for Azure (OSBA)
Open Service
Broker for Azure
(OSBA)
SQL
Database
Event
Hubs
Redis
Cache
MySQL
Database
Cosmos
DB
PosgreSQL
Database
Service
Bus
Azure
Storage
Cloud
Foundry Kubernetes
Service
FabricOpenShift
Easily access to SLA-backed Azure Services such as Azure Database for MySQL
39. *Supporting services, like storage and networking, may be charged separately.
Pay-per-use
Only pay for what you use: billing is typically calculated on
the number of function calls,
code execution time, and memory used.*
Instant, event-driven scalability
Application components react to events and triggers in
near real-time with virtually unlimited scalability;
compute resources are used as needed.
Full abstraction of servers
Developers can just focus on their code—there are
no distractions around server management, capacity
planning, or availability.
What is serverless?
40. FaaS is at the center of serverless
Functions-as-a-Service programming model use functions to achieve true serverless compute
Single responsibility
Functions are single-
purposed, reusable pieces of
code that process an input
and return a result
Short lived
Functions don’t stick around
when finished executing,
freeing up resources for further
executions
Event driven & scalable
Functions respond to
predefined events, and are
instantly replicated as many
times as needed
Stateless
Functions don’t hold any
persistent state and don’t
rely on the state of any other
processes
42. What is Azure Functions?
Anevent-based,serverlesscomputeexperiencethatacceleratesappdevelopment
Azure Functions = FaaS++
Integrated programming model
Use built-in triggers and bindings to define when
a function is invoked and to what data it connects
Enhanced development experience
Code, test and debug locally using your preferred editor or the
easy-to-use web based interface including monitoring
Hosting options flexibility
Choose the deployment model that better fits your business
needs without compromising development experience
43. Focus on code, not plumbing
No infrastructure
management
No wasted resources,
pay only for what you use
Auto-scale based
on your workload
44. Boost development efficiency
Integrate with Azure Application Insights
Get near real-time details about function apps
See metrics around failures, executions, etc.Monitoring
Save time with built-in DevOps
Deploy functions using App Service for CI
Leverage Microsoft, partner services for CDCI/CD
Use triggers to define how functions are invoked
Avoid hardcoding with preconfigured JSON files
Build serverless APIs using HTTP triggersTriggers
Connect to data with input and output bindings
Bind to Azure solutions and third-party services
Use HTTP bindings in tandem with HTTP triggersBindings
Define one API surface for multiple function apps
Create endpoints as reverse proxies to other APIs
Condition proxies to use variablesProxies
Debug C# and JavaScript functions locally
Use debugging tools in Azure portal, VS, and VS Code
Local
debugging
45. Gain flexibility and develop your way
Write code in C#, JavaScript, F#, and Java
Continuous investment in new, experimental languagesMultiple
languages
Simplify coding for new users with native Azure portal
Select from popular editors, like VS, VS Code, CLI, Maven*Dev options
Choose from six consumption plans to run Functions
Run your first million function executions for freeHosting
options
*VS and VS Code only support C#; Maven only supports Java
Write stateful functions in a serverless environment
Simplify complex, stateful coordination problems
Add the extension to enable advanced scenarios
Durable
Functions
46. Hosting
options
*Currently in preview
Only pay for what
you use; charges
apply per execution
and
per GB second
Gain all the
advantages of
Functions along with
Microsoft’s
financially-backed
SLA and the always-
on features of an
App Service Plan
Bring the power of
the entire Azure
stack
to your own
data centers
Run Functions on
your local server;
does not include the
entire
Azure stack
Use a dedicated App
Service cloud
environment (ASE)
that comes with
network isolation for
apps, greater scale,
and secure
connectivity to local
vNets
Deploy custom
Azure modules
on IoT devices
Consumption AS Plan
Serverless Free, Basic, Standard,
Premium
AS Environment
Network isolation
Azure Stack
On-premises
Runtime
Functions on your
server
IoT Edge*
On devices
Gain flexibility and develop your way
47. Azure Functions is an open-source project
Functionsruntimeandallextensionsarefullyopensource
https://github.com/Azure/Azure-Functions
52. Microsoft drives community-led innovations for Kubernetes
Microsoft also maintains…
Cloud Native
Application Bundles
(CNAB)
Virtual
KubeletHelm BrigadeDraft
68% of Kubernetes users* prefer Helm as their package manager
Visual Studio Code Kubernetes Extensions has 11K monthly active users
*August 2018 bi-annual CNCF survey
53. Work how you want with opensource tools and APIs
Development DevOps Monitoring Networking Storage Security
Take advantage of
services and tools in
the Kubernetes
ecosystem
Leverage 100+ turn-
key Azure services
VS Code
DevOps
ARM
Azure VNET Azure Storage
Container
Registry
Azure
Active
Directory
Key Vault
Azure Monitor
CNAB
Virtual kubelet
Azure Policy
54.
55. Find, share, and use software built for k8s
Manage complexity Easy updates
Simple sharing Rollbacks
56. Simple app development and deployment – into any Kubernetes cluster
Simplified development
Using two simple commands,
developers can now begin working on
container-based applications without
requiring Docker or even installing
Kubernetes themselves
Language support
Draft detects which language your app is
written in, and then uses packs to
generate a Dockerfile and Helm Chart
with the best practices for that language
66. Capabilities
1. Use Azure Dev Spaces to iteratively
develop, test, and debug microservices
targeted for AKS clusters.
2. Azure DevOps has native integration with
Helm and helps simplifying continuous
integration/continuous delivery (CI/CD)
3. Virtual node—a Virtual Kubelet
implementation—allows fast scaling of
services for unpredictable traffic.
4. Azure Monitor provides a single pane of
glass for monitoring over app telemetry,
cluster-to-container level health analytics.
https://github.com/Microsoft/SmartHotel360-AKS-DevSpaces-Demo
Source
code control
Inner loop
Azure
Container
Registry
Azure Pipeline/
DevOps Project
Auto-build
Azure
Monitor
CI/CD
Test
Debug
Azure
DevSpaces
AKS dev
cluster
AKS production cluster
Pods
Container instances
Pods
1
2
3
4
Integrated end-to-end Kubernetes experience
74. VS Code Live Share
• You just need VS Code locally
• Code and all setup on your collaborator’s machine
• Code together without setting anything up
• Access services on remote machine from localhost
• Works with Azure Dev Spaces on machine sharing
the session: double jump to AKS
77. THE PROBLEM:
Disparate ecosystems, hard transition
Monolithic Apps Microservices Serverless
Ansible Docker EE AWS 𝝀
APM
Splunk
SOA
Prometheus
OpenTracing
microservices
CloudWatch
X-RAY
Event-driven
Enterprise faces 4 main problems in
adopting innovative architectures:
1. Insolation between brown and green field
2. Transition is lengthy and diverts essential
personnel from core mission
3. Duplicate redundant tools
4. Requires silo teams
78. OUR VISION:
Hybrid App
Monolithic Apps Microservices Serverless
Ansible Docker EE AWS 𝝀
Pros: fast delivery of new features in modern architectures; stop “digging the hole”;
gradual transition = minimal interruption; unified tooling.
Hybrid app
79. Gloo will glue together
your hybrid environment
Event Request Emit
Docker Enterprise Edition Platform
Monolithic Apps Microservices
Portable
Serverless
Proprietary
Serverless
Function-level routing: canary
deployment, security, caching
Date plane: builds around and extends
the Envoy proxy (C++)
Control plane: pluggable, extensible
architecture (GO)
Centralized place to manage security,
observability, trafficEnvoy Proxy
80. Gloo will glue together
your hybrid environment
Event Request Emit
Docker Enterprise Edition Platform
Monolithic Apps Microservices
Portable
Serverless
Proprietary
Serverless
Full integration with all components
of your environment: all clouds, all
platforms, all technologies
Automatic discovery of all your
functions, services & appsEnvoy Proxy
93. Spec for packaging distributed apps
CNAB: package distributed apps
CNABs facilitate the bundling,
installing and managing of
container-native apps — and their
coupled services
Cloud Native Application Bundle
94. Install and manage distributed app bundles
Duffle: install & manage
distributed app bundles
Simple CLI to interact with CNAB,
for use with your clouds and
services of choice
Duffle
95. A friendlier cloud installer
Install your app and its baggage
Bundle up not just the app, but
everything it needs to run in the
cloud
Build bundles smarter, not harder
Use mixins for common tools and
clouds, and depend on existing
bundles.
Surprise! It does package
management too
Package and version your bundle,
then distribute it for others to use.
96. Microsoft at #GIDS19
Booth game & CosmosDB
demos
Today 14:30: Maheshkumar R
Architect your Solution using
Virtual Nodes to Auto-Scale your
Application on Kubernetes (AKS)
We’re hiring: https://aka.ms/ca-india
Tomorrow 11:30 Shashank Barsin
Traceable and Safe Deployments to
Kubernetes using CI/CD Pipelines
97. Build Viewing Parties
May 6-8 9 cities in
India
Night parties
events.microsoft.com
Ignite | The Tour
May 22nd, Mumbai
98. BUILD THE INTELLIGENT FUTURE
Announcing
Microsoft “Week of
AI”
V I R T U A L W O R K S H O P S E R I E S
27th May – 31st May, 2019
In India Timezone
To know more & register, visit:
aka.ms/WeekofAI
It’s incredibly easy to get started when using the az command line tool. Assuming you’ve created a resource group, it’s just:
az aks create
az aks install-cli
az aks get-credentials (you might need --overwrite-existing here)
That’s it – then you’re up and running and you can query the cluster via kubectl get nodes as you normally would with a Kubernetes cluster. Super simple.
Building on top of the FaaS programming model, Azure Functions keep all the mentioned features and extend your possibilities with additional capabilities that help to reduce your development time and boost productivity, while using best in class tools.
Additional information
Triggers and bindings – https://docs.microsoft.com/en-us/azure/azure-functions/functions-triggers-bindings
Monitoring—https://azure.microsoft.com/en-us/services/application-insights/
Local debugging—https://docs.microsoft.com/en-us/azure/azure-functions/functions-run-local#run-functions-locally
CI/CD—https://docs.microsoft.com/en-us/azure/azure-functions/functions-continuous-deployment
Run locally—https://docs.microsoft.com/en-us/azure/azure-functions/functions-run-local
Proxies—https://docs.microsoft.com/en-us/azure/azure-functions/functions-proxies
Additional information
Languages—https://docs.microsoft.com/en-us/azure/azure-functions/supported-languages
Dev options—
Azure Functions portal—https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-azure-function
Visual Studio—https://docs.microsoft.com/en-us/azure/azure-functions/functions-develop-vs
Visual Studio Code—https://code.visualstudio.com/docs
CLI—https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-azure-function-azure-cli
Java/Maven—https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-java-maven
Hosting options—https://azure.microsoft.com/en-us/pricing/details/functions/
Durable Functions—https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-overview
And that’s not all! Sure, Terraform plus AKS is a winning combo, but Team Azure is also involved in lots of super-cool k8s ecosystem open source. Take Helm, for example! Which is now a CNCF incubating project - we donated the IP. At this point I always feel like I need to have a content warning for YAML - if YAML upsets you, there will be so much YAML. And we need to manage all that YAML between all our environments and versions!
We use helm in AKS, azure dev spaces, azure pipelines, azure devops - this isn’t a “drink our own champagne” story - these tools support us too!
Helm manages complexity, has easy updates, allows you to easily version and share, and allows for easy release rollback. So let’s go into more detail on each!
Draft is simple app development and deployment into any kubernetes cluster. Two simple commands is all it takes for developers to start working on container-based applications. Draft also detects the language your applications are written in and uses packs to generate a Dockerfile and Helm Chart based on that programming language.
Okay, so the new, exciting shiny! Check out cnab.io if you want to jump right in.
CNAB: A spec for packaging distributed apps.
CNABs facilitate the bundling, installing and managing of container-native apps — and their coupled services.
Cloud Agnostic: A CNAB can be composed to utilize whatever infra or services you require - there’s no vendor lock in.
Deliverable Apps
CNABs can be used to easily deliver apps across teams, organizations and marketplaces - even shared offline.
Signed & Secure
A CNAB can be cryptographically signed, attested, and verified to ensure a trustworthy source.
[building all this on brigade]
Duffle is a simple command line tool that interacts with Cloud-Native Application Bundles (CNABs) - helping you package and unpackage distributed apps for deployment on whatever cloud platforms and services you use. - duffle-bag is a GUI, too.
Okay, so that’s a lot. Porter makes using CNAB easier - it’s a declarative bundle builder. When we deploy to the cloud, most of us aren’t dealing with just a single cloud provider or toolchain. The simplest of applications today need nginx, Let’s Encrypt, persistent file storage, DNS, and somewhere in there is your application. One app is installed with Helm, another with the cloud provider’s cli and it’s all glued together with magic bash scripts. That is a lot to figure out! 😅 Porter is a cloud installer that helps you manage everything together in a single bundle, focusing on what you know best: your application. Mixins: classes with methods for use by other classes (while not relying on inheritance). We can describe actions using mixins.