This talk will teach you how to redesign an event-driven autoscaling architecture for cloud-native microservices by utilizing Apache Kafka, Knative, and KEDA infrastructure. You will also learn how to deploy serverless applications (Quarkus) using a Knative service. Finally, KEDA will enable you to autoscale Knative Eventing components (KafkaSource) through events consumption over standard resources (CPU, memory).
The document provides an overview of Kubernetes concepts and architecture. It begins with an introduction to containers and microservices architecture. It then discusses what Kubernetes is and why organizations should use it. The remainder of the document outlines Kubernetes components, nodes, development processes, networking, and security measures. It provides descriptions and diagrams explaining key aspects of Kubernetes such as architecture, components like Kubelet and Kubectl, node types, and networking models.
Helm is a package manager for Kubernetes that allows for easy installation, upgrade, and management of Kubernetes applications. It provides repeatability, reliability, and simplifies deploying applications across multiple Kubernetes environments. Helm originated from an internal hackathon at Deis and was jointly developed by Google and Deis. It is now maintained by the Cloud Native Computing Foundation. Helm consists of a client that interacts with the Tiller server running inside the Kubernetes cluster to manage application lifecycles using charts, which are packages containing Kubernetes resource definitions.
Kubernetes is an open-source containerization framework that makes it easy to manage applications in isolated environments at scale. In Apache Spark 2.3, Spark introduced support for native integration with Kubernetes. Palantir has been deeply involved with the development of Spark’s Kubernetes integration from the beginning, and our largest production deployment now runs an average of ~5 million Spark pods per day, as part of tens of thousands of Spark applications. Over the course of our adventures in migrating deployments from YARN to Kubernetes, we have overcome a number of performance, cost, & reliability hurdles: differences in shuffle performance due to smaller filesystem caches in containers; Kubernetes CPU limits causing inadvertent throttling of containers that run many Java threads; and lack of support for dynamic allocation leading to resource wastage. We intend to briefly describe our story of developing & deploying Spark-on-Kubernetes, as well as lessons learned from deploying containerized Spark applications in production. We will also describe our recently open-sourced extension (https://github.com/palantir/k8s-spark-scheduler) to the Kubernetes scheduler to better support Spark workloads & facilitate Spark-aware cluster autoscaling; our limited implementation of dynamic allocation on Kubernetes; and ongoing work that is required to support dynamic resource management & stable performance at scale (i.e., our work with the community on a pluggable external shuffle service API). Our hope is that our lessons learned and ongoing work will help other community members who want to use Spark on Kubernetes for their own workloads.
As part of this presentation we covered basics of Terraform which is Infrastructure as code. It will helps to Devops teams to start with Terraform. This document will be helpful for the development who wants to understand infrastructure as code concepts and if they want to understand the usability of terrform
This document contains notes from a talk on advanced Terraform techniques. It discusses using Terraform for infrastructure as code to deploy resources across multiple environments like development, staging, and production. It also mentions techniques like separating code into modules, using variables to parameterize configurations, and integrating Terraform with other DevOps tools like Ansible.
The document discusses infrastructure as code best practices on AWS. It provides an overview of using AWS CloudFormation to define infrastructure in code. AWS CloudFormation allows infrastructure to be provisioned in an automated and repeatable way using templates that are version controlled like code. The document outlines the key components of a CloudFormation template including parameters, mappings, resources, outputs and conditionals. It also discusses using CloudFormation to bootstrap applications on EC2 instances.
Kubernetes is a system for orchestrating containerized workloads and services across many nodes that provides tools for managing replication, scaling, and state. KEDA allows Kubernetes to automatically scale function apps in response to events from sources like message queues or serverless triggers by integrating with functions running as pods and scaling them based on metrics and triggers. KEDA is useful for running serverless functions on Kubernetes in environments like on-premises, at the edge, or alongside other Kubernetes workloads where full control over scaling is needed.
Tell the history of Container/Docker/Kubernetes, and show the key elements of them. After view this document, you could know the main feature of Container Docker and Kubernetes. Very basic infomation about how these technique work together.
Helm version 3 was recently released with new features and a new architecture to support those features. The changes to Helm and charts were based on feedback, changes to Kubernetes, and lessons learned in the past couple years.
Those are the slides that were used to give an introduction to Kubernetes at the Nardoz Berlin Meetup on the 2018-06-28.
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery called pods. Kubernetes can manage pods across a cluster of machines, providing scheduling, deployment, scaling, load balancing, volume mounting and networking. It is widely used by companies like Google, CERN and in large projects like processing images and analyzing particle interactions. Kubernetes is portable, can span multiple cloud providers, and continues growing to support new workloads and use cases.
This document discusses using OpenTelemetry, Grafana, and Promscale to gain insights into distributed systems. It summarizes OpenTelemetry for instrumentation, Promscale as an observability backend built on TimescaleDB that allows analyzing metrics, traces and business data together, and demonstrates this using a lightweight microservices demo that generates absurd passwords. The demo can be run locally and visualized in Grafana.
Flink Forward San Francisco 2022. Task Managers constantly running out of memory? Flink job keeps restarting from cryptic Akka exceptions? Flink job running but doesn’t seem to be processing any records? We share practical learnings from running thousands of Flink Jobs for different use-cases and take a look at common challenges they have experienced such as out-of-memory errors, timeouts and job stability. We will cover memory tuning, S3 and Akka configurations to address common pitfalls and the approaches that we take on automating health monitoring and management of Flink jobs at scale. by Hong Teoh & Usamah Jassat
https://www.youtube.com/playlist?list=PLAiEy9H6ItrKC5PbH7KiELiSEIKv3tuov -What is Prometheus? -Difference Between Nagios vs Prometheus -Architecture -Alertmanager -Time series DB -PromQL (Prometheus Query Language) -Live Demo -Grafana
This document provides an overview of Grafana, an open source metrics dashboard and graph editor for Graphite, InfluxDB and OpenTSDB. It discusses Grafana's features such as rich graphing, time series querying, templated queries, annotations, dashboard search and export/import. The document also covers Grafana's history and alternatives. It positions Grafana as providing richer features than Graphite Web and highlights features like multiple y-axes, unit formats, mixing graph types, thresholds and tooltips.
In this session, we will start with the importance of monitoring of services and infrastructure. We will discuss about Prometheus an opensource monitoring tool. We will discuss the architecture of Prometheus. We will also discuss some visualization tools which can be used over Prometheus. Then we will have a quick demo for Prometheus and Grafana.
A basic introductory slide set on Kubernetes: What does Kubernetes do, what does Kubernetes not do, which terms are used (Containers, Pods, Services, Replica Sets, Deployments, etc...) and how basic interaction with a Kubernetes cluster is done.
Agenda: - Cloud Native vs. SaaS / Serverless Kafka - The Emergence of Kubernetes - Kafka on K8s Deployment Challenges - Confluent Operator as Kafka Operator - Q&A Confluent Operator enables you to: Provisioning, management and operations of Confluent Platform (including ZooKeeper, Apache Kafka, Kafka Connect, KSQL, Schema Registry, REST Proxy, Control Center) Deployment on any Kubernetes Platform (Vanilla K8s, OpenShift, Rancher, Mesosphere, Cloud Foundry, Amazon EKS, Azure AKS, Google GKE, etc.) Automate provisioning of Kafka pods in minutes Monitor SLAs through Confluent Control Center or Prometheus Scale Kafka elastically, handle fail-over & Automate rolling updates Automate security configuration Built on our first hand knowledge of running Confluent at scale Fully supported for production usage
Event Driven Autoscaling with KEDA can save you a lot of trouble with different issues/troubles which you can see with traditional HPA/VPA based workloads.
This document discusses Kubernetes event-driven autoscaling (KEDA) which allows deployments to scale based on external events rather than resource metrics. KEDA monitors event sources like queues and scales the workload by modifying the horizontal pod autoscaler. It supports scaling deployments from zero replicas and scaling batch jobs. Real-world examples of using KEDA include scaling game workload for events and processing messages from queues in batches.
There's too much fragmentation for developers when it comes to deciding the right open source FaaS solution. Bryan Friedman and Brian McClain detail Knative, an open source project from Google, Pivotal, and other industry leaders that provides a set of common tooling on top of Kubernetes to help developers build functions.