eBPF vs Sidecars by Liz Rice at Isovalent

1. The document discusses JIB and Google Cloud Run for containerizing Java applications. 2. JIB is a tool that builds container images for Java applications faster and produces smaller images. It works by compiling the application to a container image without using Dockerfiles or needing a Docker daemon. 3. Google Cloud Run is a serverless platform that allows running containerized applications without having to manage infrastructure. It provides a fully managed environment to deploy containers.

Kubernetes is also called the "distributed Linux of the cloud" – which implies that it provides fundamental infrastructure, which can solve a lot of challenges. Let’s see how PHP applications fit into this picture. In this presentation, we are going to explore when Kubernetes is a good fit for operating your PHP application and how it can be done in practice. We’ll look at the whole lifecycle: how to build your application, create or choose the right Docker images, deploy and scale, and how to deal with performance and monitoring. At the end you will have a good understanding about all the different stages and building blocks for running a PHP application with Kubernetes in production.

API Gateways are certainly not a new technology, but the way in which they are being deployed, configured, and operated within modern platforms is forcing many of us to rethink our approach. Can we simply lift and shift our existing gateway into the cloud? Is our API gateway GitOps friendly (and does it need to be)? And what about service meshes, CNI, eBPF, and... Join this talk for a whistle stop tour of modern API gateways, which a focus on deploying and managing this technology within Kubernetes (on which many modern platforms are built): - Understand why platform engineers should care about API Gateways today - Learn about API gateways, options, and requirements for modern platforms - Identify key considerations for migrating to the cloud or building a new platform on Kubernetes - Understand how cloud native workflows impact the user/developer experience (UX/DX) of an API gateway - Explore the components of a complete "edge stack" that supports end-to-end development flows

This document provides an agenda for a training on iOS application penetration testing. It covers topics such as setting up an iOS pen testing environment, understanding the iOS filesystem and Objective-C runtime, runtime analysis and manipulation, insecure data storage, analyzing network traffic, jailbreak detection, secure coding guidelines, and automated testing. Tools discussed include class-dump-z, cycript, clutch, and gdb for analyzing iOS applications.

The document describes IBM's transition from a single-tenant Hadoop architecture for their Watson Analytics for Social Media product to a multitenant Apache Spark architecture supporting over 3000 tenants. Key aspects of the new architecture included splitting analytics into tenant-specific and language-specific components, aggregating social media feeds from all tenants into a single stream for processing, and removing tenant state from processing components to enable low-latency switching between tenants. This resulted in a scalable, robust pipeline for real-time social media analytics based on Spark, Kafka and Zookeeper.

- WHAT IS WATSON ANALYTICS FOR SOCIAL MEDIA - PREVIOUS ARCHITECTURE ON HADOOP - THOUGHT PROCESS TOWARDS MULTITENANCY - NEW ARCHITECTURE ON TOP OF APACHE SPARK - LESSONS LEARNED

This document summarizes options for dependency management in iOS development projects. It discusses Cocoapods, Carthage, and Swift Package Manager, outlining the basic steps to set up each and comparing their key features. Cocoapods is the most full-featured but written in Ruby. Carthage is simpler but requires more manual setup. Swift Package Manager is built into Swift but still maturing. The document provides an overview to help developers choose the right approach for their needs and project requirements.

The document discusses IBM's transition from a single-tenant Hadoop architecture to a multi-tenant Apache Spark architecture for their Watson Analytics for Social Media product. The new architecture aggregates social media data from thousands of tenants into a single stream and uses Spark, Kafka and Zookeeper to provide robust real-time analytics with low latency switching between tenants. Key aspects of the new architecture include separating analytics into tenant-specific and language-specific components, and removing state from processing components.

Speaker: Amy Cheong - Software Engineer at Tigerspike Amy will be sharing her experiences during this year’s try! Swift Tokyo in March as well as presenting some follow-up researches and presenter notes on topics she finds are interesting during the conference. Event Page: https://www.meetup.com/Singapore-iOS-Dev-Scout-Meetup/events/238766209/ Produced by Engineers.SG

On Friday 5 June 2015 I gave a talk called Cluster Management with Kubernetes to a general audience at the University of Edinburgh. The talk includes an example of a music store system with a Kibana front end UI and an Elasticsearch based back end which helps to make concrete concepts like pods, replication controllers and services.

The document discusses tools and techniques used by Uber's Hadoop team to make their Spark and Hadoop platforms more user-friendly and efficient. It introduces tools like SCBuilder to simplify Spark context creation, Kafka dispersal to distribute RDD results, and SparkPlug to provide templates for common jobs. It also describes a distributed log debugger called SparkChamber to help debug Spark jobs and techniques like building a spatial index to optimize geo-spatial joins. The goal is to abstract out infrastructure complexities and enforce best practices to make the platforms more self-service for users.

Deep learning is useful for enterprises tasks in the field of speech recognition, image classification, AI chatbots and machine translation, just to name a few. In order to train deep learning/machine learning models, applications such as TensorFlow / MXNet / Caffe / XGBoost can be leveraged. And sometimes these applications will be used together to solve different problems. To make distributed deep learning/machine learning applications easily launched, managed, monitored. Hadoop community has introduced Submarine project along with other improvements such as first-class GPU support, container-DNS support, scheduling improvements, etc. These improvements make distributed deep learning/machine learning applications run on YARN as simple as running it locally, which can let machine-learning engineers focus on algorithms instead of worrying about underlying infrastructure. Also, YARN can better manage a shared cluster which runs deep learning/machine learning and other services/ETL jobs with these improvements. In this session, we will take a closer look at Submarine project as well as other improvements and show how to run these deep learning workloads on YARN with demos. Audiences can start trying running these workloads on YARN after this talk. Speakers: Sunil Govindan, Staff Engineer Hortonworks Zhankun Tank, Staff Engineer Hortonworks

This document discusses using containers and Kubernetes for local development and deployment of Laravel applications. It begins with an introduction to containers using Docker and Docker Compose. It then discusses using Kubernetes to distribute applications across multiple hosts for production. Key concepts covered include pods, deployments, services, configmaps, and using YAML files for declarative configuration in Kubernetes. The document provides recommendations for using tools like Laradock and Larakube to simplify deploying Laravel in containers and Kubernetes.

This document discusses using Chef on SmartOS. It begins with an introduction to the speaker and their company Wanelo. It then provides an overview of SmartOS and zones, and explains benefits like ZFS, visibility tools, and lower latency. The document discusses using the knife-joyent plugin to manage SmartOS servers from Chef, including creating servers, listing servers, and managing keys. It notes some differences in SmartOS like package and service management. Finally it discusses useful LWRPs and cookbooks for using Chef on SmartOS.

This document introduces Phoenix, a web framework for building scalable and fault-tolerant distributed systems with Elixir and Erlang. It discusses how Moore's Law has led to more multi-core machines requiring better support for concurrency. Phoenix provides productivity benefits like Rails while enabling applications to handle massive concurrency through Elixir and Erlang's actor model and lightweight processes. The document demonstrates building basic and real-time web apps with Phoenix as well as using it as the web layer for distributed systems.

This document discusses the challenges of large monolithic frontend applications and proposes microfrontends as an architectural approach to address these challenges. It describes different patterns for implementing microfrontends, including mini single-page applications (SPAs) separated by links, a single SPA with multiple independently developed components, and using web components for tighter integration. Key challenges discussed are performance, shared dependencies, and inter-component communication. Examples and demos of single-spa and Angular elements are also referenced.

The document discusses the p2 API, which provides three levels of functionality - a graphical user interface, headless operations, and core APIs. It describes how each level can be used and accessed, such as how to reuse existing UI elements, perform headless install/update operations, query metadata repositories, and get information about installed software from profiles. The goal of the API is to provide functionality that ranges from simple to complex while being tailored to different user needs.

In this presentation, we explore how standard profiling and monitoring methods may fall short in identifying bottlenecks in low-latency data ingestion workflows. Instead, we showcase the power of simple yet clever methods that can uncover hidden performance limitations. Attendees will discover unconventional techniques, including clever logging, targeted instrumentation, and specialized metrics, to pinpoint bottlenecks accurately. Real-world use cases will be presented to demonstrate the effectiveness of these methods. By the end of the session, attendees will be equipped with alternative approaches to identify bottlenecks and optimize their low-latency data ingestion workflows for high throughput.

Stream processing is a crucial component of modern data infrastructure, but constructing an efficient and scalable stream processing system can be challenging. Decoupling compute and storage architecture has emerged as an effective solution to these challenges, but it can introduce high latency issues, especially when dealing with complex continuous queries that necessitate managing extra-large internal states. In this talk, we focus on addressing the high latency issues associated with S3 storage in stream processing systems that employ a decoupled compute and storage architecture. We delve into the root causes of latency in this context and explore various techniques to minimize the impact of S3 latency on stream processing performance. Our proposed approach is to implement a tiered storage mechanism that leverages a blend of high-performance and low-cost storage tiers to reduce data movement between the compute and storage layers while maintaining efficient processing. Throughout the talk, we will present experimental results that demonstrate the effectiveness of our approach in mitigating the impact of S3 latency on stream processing. By the end of the talk, attendees will have gained insights into how to optimize their stream processing systems for reduced latency and improved cost-efficiency.

Widya Salim and Victor Ma will outline the causal impact analysis, framework, and key learnings used to quantify the impact of reducing Twitter's network latency.

BlazingMQ is a new open source* distributed message queuing system developed at and published by Bloomberg. It provides highly-performant queues to applications for asynchronous, efficient, and reliable communication. This system has been used at scale at Bloomberg for eight years, where it moves terabytes of data and billions of messages across tens of thousands of queues in production every day. BlazingMQ provides highly-available, fault-tolerant queues courtesy of replication based on the Raft consensus algorithm. In addition, it provides a rich set of enterprise message routing strategies, enabling users to implement a variety of scenarios for message processing. Written in C++ from the ground up, BlazingMQ has been architected with low latency as one of its core requirements. This has resulted in some unique design and implementation choices at all levels of the system, such as its lock-free threading model, custom memory allocators, compact wire protocol, multi-hop network topology, and more. This talk will provide an overview of BlazingMQ. We will then delve into the system’s core design principles, architecture, and implementation details in order to explore the crucial role they play in its performance and reliability. *BlazingMQ will be released as open source between now and P99 (exact timing is still TBD)

Noisy Real User Monitoring (RUM) data can ruin your P99! We introduce a fresh concept called ""Human Visible Navigations"" (HVN) to tackle this risk; we focus on the experiences you actually care about when talking about the speed of our sites: - Human: We exclude noise coming from bots and synthetic measurements. - Visible: We remove any partial or fully hidden experiences. These tend to be very slow but users don’t see this slowness. - Navigations: We ignore lightning fast back-forward navigations which usually have few optimisation opportunities. Adopting Human Visible Navigations provides you with these key benefits: - Fewer changes staying below the radar - Fewer data fluctuations - Fewer blindspots when finding bottlenecks - Better correlation with business metrics This is supported by plenty of real world examples coming from the world's largest scale modeling site (6M Monthly visits) in combination with aggregated data from the brand new rumarchive.com (open source) After attending this session; your P99 and other percentiles will become less noisy and easier to tune!

Understanding the impacts of running a containerized Go application inside Kubernetes with a focus on the CPU.

In this session, Tanel introduces a new open source eBPF tool for efficiently sampling both on-CPU events and off-CPU events for every thread (task) in the OS. Linux standard performance tools (like perf) allow you to easily profile on-CPU threads doing work, but if we want to include the off-CPU timing and reasons for the full picture, things get complicated. Combining eBPF task state arrays with periodic sampling for profiling allows us to get both a system-level overview of where threads spend their time, even when blocked and sleeping, and allow us to drill down into individual thread level, to understand why.

Performance budgets have been around for more than ten years. Over those years, we’ve learned a lot about what works, what doesn’t, and what we need to improve. In this session, Tammy revisits old assumptions about performance budgets and offers some new best practices. Topics include: • Understanding performance budgets vs. performance goals • Aligning budgets with user experience • Pros and cons of Core Web Vitals • How to stay on top of your budgets to fight regressions

Trying to figure out why your application is responding late can be difficult, especially if it is because of interference from the operating system. This talk will briefly go over how to write a C program that can analyze what in the Linux system is interfering with your application. It will use trace-cmd to enable kernel trace events as well as tracing lock functions, and it will then go over a quick tutorial on how to use libtracecmd to read the created trace.dat file to uncover what is the cause of interference to you application.

With the low-latency garbage collector ZGC, GC pause times are no longer a big problem in Java. With sub-millisecond pause times there are instead other things in the GC and JVM that can cause application threads to experience unexpected latencies. This talk will dig into a specific use where the GC pauses are no longer the cause of unexpected latencies and look at how adding generations to ZGC help lower the p99 application latencies.