Combining Cloud Native & PaaS: Building a Fully Managed Application Platform on Kubernetes
0 likes30 views
DigitalOcean App Platform is a managed Platform as a Service (PaaS) that abstracts infrastructure and encodes cloud-native best practices. It provides declarative specifications for deploying stateless web applications from Git repositories with continuous delivery. Apps benefit from built-in services like auto-scaling, ingress routing, CDN, monitoring and more. The platform is built on Kubernetes and cloud-native technologies to provide a fully managed environment for deploying 12-factor apps.
Ad
More Related Content
What's hot (17)
Similar to Combining Cloud Native & PaaS: Building a Fully Managed Application Platform on Kubernetes (20)
Ad
More from DigitalOcean (20)
Ad
Recently uploaded (20)
Combining Cloud Native & PaaS: Building a Fully Managed Application Platform on Kubernetes
- 2. Steven Normore, Engineering Manager, App Platform @ DigitalOcean
- 3. DigitalOcean App Platform is a managed application PaaS that abstracts and encodes best practices of building and operating cloud-native web applications.
- 4. PaaS vs IaaS Cloud-Native & 12Factor Apps Principles Benefits DigitalOcean App Platform Cloud-Native PaaS Cloud-Native Technologies Takeaways & Guidance Outline
- 5. PaaS vs IaaS Virtualization Servers Storage Networking IaaS PaaS Applications Data Runtime Operating Systems
- 6. Cloud-Native Applications Continuous Delivery Containers Microservices DevOps
- 7. Continuous Delivery Release quickly, reliably, and frequently, with less risk.
- 8. Containers Lightweight virtualization offering efficiency and reproducibility, while abstracting away the underlying operating system.
- 9. Microservices Modular and loosely coupled services, communicating via API contracts, that can be deployed and scaled independently.
- 10. DevOps Collaboration between software developers and operations with the goal of automating delivery of software and infrastructure changes.
- 11. Cloud-Native: Benefits Faster time to market More agility Right-sized scale Collaboration Rapid recovery
- 12. 12Factor Applications Declarative specifications for setup automation. Clean contract with the underlying operating system. Suitable for deployment on modern cloud platforms. Parity between development and production environments. Scale up without significant changes.
- 13. 12Factor Principles Codebase Dependencies Config Backing services Build, release, run Stateless processes Port binding Concurrency Disposability Dev/prod parity Logs Admin processes
- 14. Codebase Tracked in a revision control system such as Git. Deployments associated with specific code versions. Deployments are automatic.
- 15. Dependencies Explicitly declare dependencies via a manifest. Isolate dependencies to avoid leaking implicit dependencies.
- 16. Config Store config in the environment. Use environment variables.
- 17. Backing Services Backing services treated as attached resources. Communicate through API contracts. Decoupled from specific instances.
- 18. Build, Release, Run Strictly separate build and run stages. Ensures no changes can be made to code at runtime. Ensures runtimes are identical as processes scale.
- 19. Stateless Processes Execute apps as one or more stateless processes. Data is persisted to a backing store. Allows processes to scale without syncing state.
- 20. Port Binding Self-contained web services. Bind to the port passed into the environment variable $PORT. Avoids reliance on runtime injection of a web server.
- 21. Concurrency Scale up via the process model. Prefer horizontal scaling over vertical scaling. Encourage breaking apps into modular components.
- 22. Disposability Robustness with fast startup and graceful shutdown. Robustness against sudden crashes and failures. Facilitates fast elastic scaling. Rapid and robust code deployment and config changes.
- 23. Dev/Prod Parity Keep development, staging, and production as similar as possible. Minimize time between coding and deploying. Code authors and deployers should be the same people.
- 24. Logs Treat logs as event streams that you write to stdout. Apps are not responsible for routing or storing its logs. Facilitates self-contained apps and minimizes dependencies.
- 25. Admin Processes Run admin and management tasks as one-off processes. Run against a specific release in a specific runtime environment. Admin code is shipped with application code.
- 26. 12Factor Principles: Benefits Minimizes time and cost for new developers joining the project. Maximizes portability between execution environments. Removes the need for servers and systems administration. Enables continuous delivery. Optimizes for agility. Prioritizes performance and reliability.
- 28. Declarative app specification. Deploy web services, static sites, background workers, and jobs. Integrate directly with DO managed databases. Continuous delivery from Git repositories. Auto-build with Buildpacks or bring your own Dockerfile. Built-in container health checks and zero-downtime deployments. Built-in global CDN with SSL for all domains. Built-in ingress with path-based routing. Scale up and out easily. Built-in monitoring, alerting, and logging. App Platform is a Cloud-Native PaaS
- 29. Declarative app specification Declarative spec defines the app desired state. Clone, reuse, and share apps easily. Parity between staging and production environments.
- 30. Deploy web services, static sites, background workers, and jobs Combine components to make a full app. Encourage modular and loosely coupled components. Enable components to scale independently. Support one-off admin and maintenance processes.
- 31. Continuous delivery from Git repositories Build and deploy from a codebase with revision control. Build, release, run — decoupled build and run stages. Parity between environments through continuous delivery. Encourage DevOps by abstracting away the CI/CD infrastructure.
- 32. Auto-build with Buildpacks or bring your own Dockerfile Build and run stateless containers. Encourage decoupled environment config. Parity between environments through shared build strategies. Get started quickly.
- 33. Built-in container health checks and zero-downtime deployments Zero-downtime deployments using rolling updates. Support continuous delivery. Robustness against app failure and degradation.
- 34. Built-in global CDN with SSL for all domains Global CDN for web services and static sites. SSL for all domains as the default. Bring your own custom domains. DDoS protection built-in.
- 35. Built-in ingress with path-based routing Route to app services based on URL path behind the same domain. Load-balance across multiple instances of your services. Supports breaking app into modular services.
- 36. Scale up and out easily Scale vertically or horizontally as needed. Scale components independently. Zero-downtime scaling with health checks.
- 37. Built-in monitoring, alerting, and logging Logs from container stdout and stderr available via API. Insights and alerting for app containers and ingress. Apps are not responsible for managing its logs or metrics.
- 38. App Platform is built on Cloud-Native technologies Running on a fleet of multi-tenant Kubernetes DOKS clusters. Workload isolation using gVisor. Network isolation using Cilium. Auto-build using Buildpacks and Kaniko. Global CDN with SSL for all using Cloudflare. Ingress with path-based routing using Istio and Envoy. App monitoring and alerting using Prometheus. App logging using Fluent Bit.
- 39. Takeaways & Guidance Keep your app components stateless; local disk is ephemeral. Break your app into modular components. Inject config as environment variables. Services can bind to $PORT. Bring your own Dockerfile for more control.
- 40. Thanks! Get in touch @snormore