Rust and Redis - Solving Problems for Kubernetes by Ravi Jagannathan of VMware - Redis Day Seattle 2020

Jan 29, 2020Download as PPTX, PDF0 likes309 views

This document discusses using Rust and Redis to build cloud native platforms. It first provides context about devops and the need to do more with less. It then discusses how platforms are becoming more distributed and Kubernetes upends distribution paradigms. The document dives into how Rust addresses issues like concurrency and systems programming. It also discusses how Redis can be used for caching, queues, streams and more. Finally, it mentions that Rust and Redis will be demonstrated.

PRESENTED BY
Rust and Redis solving { for k8 }
Ravi Jagannathan
Kubernetes Architect. VMWare

PRESENTED BY
1 What
Cloud Native Platform
2 Where
Platform Services
3 How
Rust / Redis is one way
Agenda:

PRESENTED BY
Devops: Preamble
Everything rides on the platform
But .. We are still expected to do more with Less !!
“ into this house we’re born”

PRESENTED BY
World of 24/7 service
• Fault lines are blurry
– Between teams
• Services cant stop
– User impact
• Users base is increasing
– New avenues
• Failure is expected
– Plan on it
• Devops / SRE is a buffer area for impact
– It touches everything
Platform provides a contract
SRE / Devops

PRESENTED BY
Platforms are becoming distributed
Not everything is in one place to reason
Chaos creeps in.. Difficult to pin problems

PRESENTED BY
K8 upends the Distribution paradigm
Decentralized Pattern
• K8 native objects { new CRD / Verbs from new services }
• Client Go - pattern { client api access }
• Event model to tap into { Informers / listers }
• Ephemeral workloads and services
Business Critical workloads are majority outside K8.

PRESENTED BY
Rust :
• Problem Rust addresses
– Non-mutable runtime
– Concurrency
– Better C
– Systems programming is easy
Rust / Redis {PbJ}
Redis :
• Easy / Performant
– CRDT {new CAP theorem}/In-memory replication
– Data structure to choose
– Cache / KV / Doc / SQL
– Streams / Graph
– AI / TensorFlow

PRESENTED BY
Safety , Speed and Concurrency
You must be this tall to write concurrent code!!
Before Rust

PRESENTED BY
Building blocks
Zero cost abstraction + Memory safety data race freedom
confident productive systems programming
Ownership and borrowing
Futures
Concurrency
No runtime cost

PRESENTED BY
Tokio” : mio + futures
• Event loop
• Concurrency
• Non-blocking I/O
• Ownership and type system
• Backpressure
• Lightweight
• No garbage collector
Result of computation done in the background so we can do other things

PRESENTED BY
Redis patterns
• Cache
• Event-driven Architecture
– Queues
– Pub/Sub
– Streams
• Indexer
• Global CRDT
Heavy lift concerns !!

PRESENTED BY
Rust users in the wild
• Mozilla
• Facebook
• Microsoft Azure
• Dropbox

PRESENTED BY
Demo
• Redis performance
• Rust Concurrency

This document discusses using Redis caching to improve performance for the DBS Paylah mobile wallet application. Paylah aims to significantly increase its user base which will increase load on its backend systems. Caching application data and session state in Redis can reduce latency, improve responsiveness for users, and reduce costs by lowering load on legacy backend databases and mainframes. The document outlines some key Paylah use cases where caching transaction histories and account details in Redis would accelerate retrieval and improve the mobile experience by avoiding the need to access slower backend systems on each request.

Highly Available Persistent Session Management Service by Mohamed Elmergawi o...Redis Labs

The document discusses the challenges of building a highly available persistent session management service. It describes Zulily's legacy architecture which lacked high availability and required manual intervention. A new architecture is proposed using Redis for persistent storage, Dynomite for real-time replication across data centers, and a connection pooling proxy to improve efficiency and distribute load. The architecture provides high availability through replication, reduces overhead through connection pooling, and handles failures through consistent hashing and health checks. It was tested through simulations and showed a failure rate of only 0.42% during outages.

A Low-latency Logging Framework by Rajat Panwar of HolidayMe - Redis Day Bang...Redis Labs

This document discusses using Redis as a low latency logging framework for serverless applications. It outlines some common challenges with logging in serverless environments due to lack of access to the operating system and local storage. The document then proposes using Redis to store logs with an RPUSH/LPOP pattern to achieve very low latency logging without data size limitations. It provides some benchmarks showing latency reduction from 117ms to 25ms on average and ability to ingest up to 15GB of logs per hour. Finally, it discusses future plans to use the Disque module for job queueing to efficiently handle retries of failed scenarios.

Solving Complex Scaling Problems by Prashant Kumar and Abhishek Jain of Myntr...Redis Labs

Redis was used by Myntra to solve several complex scaling problems. It was used to build a scalable user segment service to support high read throughput of up to 5 million requests per minute with low latency. Redis allowed the service to scale beyond a single instance and included features like automatic backups and memory management. Redis also helped build a scalable mobile verification platform to reliably handle 100,000 requests per minute and scale to support higher future volumes. It was used as both a transient store and persistent backend. Finally, Redis locks helped build a scalable A/B testing platform by allowing experiments to be created and updated in an orderly concurrent fashion.

Leveraging Redis for System Monitoring by Adam McCormick of SBG - Redis Day S...Redis Labs

The document discusses how Sinclair Broadcast Group leverages Redis for system monitoring of its content delivery network. It operates 193 news stations with 10,000 active pages daily and millions in archive. New stories are posted every 15 seconds and must be visible across its 1,000+ targets within 1 minute. Redis is used to track performance across the multi-level CDN and ensure service level agreements are met with real-time resolution and alerting. It provides a black box view of the audience experience and can scale monitoring to all relevant pages within 30 seconds. Redis acts as a distributed data store to parallelize the monitoring task across the large scale of the network.

Moving Beyond Cache by Yiftach Shoolman - Redis Day Bangalore 2020Redis Labs

This document summarizes a presentation about Redis and Redis Enterprise. It discusses how Redis can be used as a database due to its fast performance, modern data types, and ability to share data across deployments. It highlights Redis modules like RediSearch for full-text search and RedisGraph for graph databases. Redis Enterprise provides additional features like high availability, geo-distribution, durability, security and multi-tenancy. It also discusses how Redis Enterprise enables active-active deployments across regions with CRDTs for strong consistency and high performance.

SQL, Redis and Kubernetes by Paul Stanton of Windocks - Redis Day Seattle 2020Redis Labs

The document discusses common use cases for combining SQL, Redis, and Kubernetes including caching, session management, rate limiting, and data ingestion. It outlines how Kubernetes can be used for scaling microservices while Redis is used for data service scaling. The presentation proposes combining Redis, SQL Server, and Kubernetes with a proxy service, and describes using Redis for caching, session storage, and rate limiting of SQL data. It also discusses running Redis and front-end apps on Kubernetes and deploying SQL as a Kubernetes service through a proxy.

RedisConf17 - Redfin - The Real Estate Brokerage and the In-memory Database Redis Labs

Redfin uses Redis as an in-memory database to power caching, rate limiting, real-time analytics and more. Redis provides fast performance and useful data structures and features like Lua scripting, pub/sub, hyperloglog and hashes. Some current uses include caching API responses, database queries and map data. Redis is also used for rate limiting external APIs. Future potential uses discussed include session storage, text search, chat, distributed locks, modules for new data types and behaviors.

Build a High-performance Partner Analytics Platform by Ashish Jadhav and Neer...Redis Labs

RedisConf17 - Roblox - How Roblox Keeps Millions of Users Up to Date with Red...Redis Labs

Roblox is a social gaming platform with millions of users that uses Redis and a custom Redis Pub/Sub backplane to deliver real-time messages at scale. The system handles over 1 million concurrent connections and delivers 20,000 messages per second. It uses Redis for caching, rate limiting, and as a datastore. The system was designed for best effort delivery without guarantees and limits notifications by user, connection, and message size. It has been successfully scaled through capacity planning and automated testing.

Achieving end-to-end visibility into complex event-sourcing transactions usin...HostedbyConfluent

Event-sourcing systems usage like Kafka is growing rapidly among Node.js applications. Building systems around an event-driven architecture simplifies horizontal scalability in distributed computing models and makes them more resilient to failure. With these advantages, we face new challenges - how to get visibility into these complex processes. Event-driven architecture is async by nature. Tracking the communication between different components is both extremely difficult and important when debugging or figuring out bottlenecks in the system. In this talk, I will present ways to achieve end-to-end and granular visibility into complex event-sourcing transactions using distributed tracing. I will use open-source tools like OpenTelemetry, Jaeger, and Zipkin to showcase a complex Node.js system using Kafka.

RedisConf18 - Designing a Redis Client for Humans Redis Labs

This document discusses designing Redis clients that are easy for humans to use. It celebrates the success of Redis and its client ecosystem but notes some common problems clients face. It acknowledges the complexity added by Redis server features and network topologies. The document encourages both existing and new client authors to help address these problems and make clients even more full-featured and user-friendly.

The Road Most Traveled: A Kafka Story | Heikki Nousiainen, AivenHostedbyConfluent

When moving to a cloud native architecture Moogsoft knew they needed more scale than Rabbit could provide. Moogsoft moved into Kafka which is known for quick writing and driving heavy event driven workloads on top of niceties such as replayability. Choosing the tool was easy, finding a vendor that ticked all their boxes was not. They needed to ensure scalability, upgradability, builds via existing IAC pipelines, and observability via existing tools. When Moogsoft found Aiven, they were impressed with their offering and ability to scale on demand. During this presentation we will explore how Moogsoft used Aiven for Kafka to manage and scale their data in the cloud.

Redis Day TLV 2018 - 5 Redis Use Cases That Power the Datorama Query APIRedis Labs

The document discusses 5 ways that Redis is used to power the Datorama Query API. Redis is used for caching to speed up queries, queueing to distribute workloads across servers, locking to prevent conflicting operations, throttling to manage congestion, and publishing/subscribing to provide immediate feedback. Together these 5 Redis uses cases allow the distributed and data-intensive Datorama Query API to handle billions of rows processed and millions of calls per second daily.

Devops Days, 2019 - Charlottebotsplash.com

- Ramu Pulipati presented on Botsplash's journey to implement continuous integration and delivery (CI/CD) processes. They initially used shell scripts and Ansible but found deployment took too long. They then tried Circle CI but had issues with dynamic IP ranges and SSH key distribution. They moved to using AWS Code Suite (CodeBuild, CodeDeploy, CodePipeline) but found it added complexity and was difficult to evolve. Their lessons were to start simple, set clear goals, and accomplish them incrementally rather than taking on too much at once.

URP? Excuse You! The Three Metrics You Have to Know confluent

(Todd Palino, LinkedIn) Kafka Summit SF 2018 What do you really know about how to monitor a Kafka cluster for problems? Is your most reliable monitoring your users telling you there’s something broken? Are you capturing more metrics than the actual data being produced? Sure, we all know how to monitor disk and network, but when it comes to the state of the brokers, many of us are still unsure of which metrics we should be watching, and what their patterns mean for the state of the cluster. Kafka has hundreds of measurements, from the high-level numbers that are often meaningless to the per-partition metrics that stack up by the thousands as our data grows. We will thoroughly explore three key monitoring concepts in the broker, that will leave you an expert in identifying problems with the least amount of pain: -Under-replicated Partitions: The mother of all metrics -Request Latencies: Why your users complain -Thread pool utilization: How could 80% be a problem? We will also discuss the necessity of availability monitoring and how to use it to get a true picture of what your users see, before they come beating down your door!

Understanding Kafka Produce and Fetch api calls for high throughtput applicat...HostedbyConfluent

The data team at Cloudflare uses Kafka to process tens of petabytes a day. All this data is moved using the 2 foundational Kafka api calls: Produce (api key 0) and Fetch (api key 1). Understanding the structure of these calls (and of the underlying RecordSet structure) is key to building high throughput clients. The talk describes the basics of the Kafka wire protocol (api keys, correlation id), and the structure of the Produce and Fetch calls. It shows how the asynchronous nature of the wire protocol can combine with the structure of the Produce and Fetch calls to increase latency and reduce client throughput; a solution is offered through use of synchronous single-partition calls. The RecordSet structure, which is used to encode and store sets (batches) of records is described, and its implications on Fetch requests are discussed. The relationship between Fetch api calls and ""consume"" operations is discussed, as is the impact of offset alignment to RecordSet boundaries.

RedisConf17 - Explosion of Data at the Edge in EquinixRedis Labs

This document discusses Equinix's plans to implement a microservices architecture and edge caching capabilities for their DCIM platform. The new architecture aims to address challenges from Equinix's large, global, and heterogeneous infrastructure by breaking the application into independent, containerized microservices. This will improve scalability, performance, fault tolerance, and deployments. The architecture will leverage edge processing by caching data and services at local data centers to reduce latency and enable offline functionality.

One Click Streaming Data Pipelines & Flows | Leveraging Kafka & Spark | Ido F...HostedbyConfluent

The Apache Kafka ecosystem is very rich with components and pieces that make for designing and implementing secure, efficient, fault-tolerant and scalable event stream processing (ESP) systems. Using real-world examples, this talk covers why Apache Kafka is an excellent choice for cloud-native and hybrid architectures, how to go about designing, implementing and maintaining ESP systems, best practices and patterns for migrating to the cloud or hybrid configurations, when to go with PaaS or IaaS, what options are available for running Kafka in cloud or hybrid environments and what you need to build and maintain successful ESP systems that are secure, performant, reliable, highly-available and scalable.

Monitoring and Resiliency Testing our Apache Kafka Clusters at Goldman Sachs ...HostedbyConfluent

In our payments platform at Goldman Sachs Transaction Banking, Apache Kafka plays a critical role as the messaging bus in our micro-services architecture. Being a part of the financial service industry we need to ensure high-availability of our platform and quick response time during failures. In this talk we will explore how we monitor and alert on the health of our Kafka clusters using our heartbeat application and clients using DataDog dashboards. We will see how we consolidate JMX metrics such as error-rates, connection-rates, latencies and consumer lag from all producers and consumers using JMX agent sidecar to provide a live view of the health of our entire infrastructure. We will also discuss our culture of game days where we regularly test the resiliency of all the clients in our infrastructure by simulating various failure scenarios to improve the overall availability of our infrastructure.

How Zillow Unlocked Kafka to 50 Teams in 8 months | Shahar Cizer Kobrinsky, Z...HostedbyConfluent

1. Zillow transitioned from using multiple messaging systems and data pipelines to using Kafka as their single streaming platform to unify their data infrastructure. 2. They took a bottom-up approach to gain trust from teams by publishing service level objectives, onboarding non-critical streams quickly, and meeting developers where they were with tools like Terraform. 3. An important lesson was to treat the platform as a product by providing documentation, libraries, and blog posts to make it easy for developers to use.

Tradeoffs in Distributed Systems Design: Is Kafka The Best? (Ben Stopford and...HostedbyConfluent

When choosing an event streaming platform, Kafka shouldn’t be the only technology you look at. There are a plethora of others in the messaging space today, including open source and proprietary software as well as a range of cloud services. So how do you know you are choosing the right one? A great way to deepen our understanding of event streaming and Kafka is exploring the trade-offs in distributed system design and learning about the choices made by the Kafka project. We’ll look at how Kafka stacks up against other technologies in the space, including traditional messaging systems like Apache ActiveMQ and RabbitMQ as well as more contemporary ones, such as BookKeeper derivatives like Apache Pulsar or Pravega. This talk focuses on the technical details such as difference in messaging models, how data is stored locally as well as across machines in a cluster, when (not) to add tiers to your system, and more. By the end of the talk, you should have a good high-level understanding of how these systems compare and which you should choose for different types of use cases.

Building Retry Architectures in Kafka with Compacted Topics | Matthew Zhou, V...HostedbyConfluent

In this talk, we'll discuss how VillageMD is able to use Kafka topic compaction for rapidly scaling our reprocessing pipelines to encompass hundreds of feeds. Within healthcare data ecosystems, privacy and data minimalism are key design priorities. Being able to handle data deletion in a reliable, timely manner within event-driven architectures is becoming more and more necessary with key governance frameworks like the GDPR and HIPAA. We'll be giving an overview of the building and governance of dead-letter queues for streaming data processing. We'll discuss: 1. How to architect a data sink for failed records. 2. How topic compaction can reduce duplicate data and enable idempotency. 3. Building a tombstoning system for removing successfully reprocessed records from the queues. 4. Considerations for monitoring a reprocessing system in production -- what metrics, dataops, and SLAs are useful?

RedisConf17 - Pain-free PipeliningRedis Labs

The document discusses how pipelining commands can improve performance when making requests to Redis over a network. It shows that pipelining multiple commands together can increase throughput significantly by reducing the number of round trips needed to the server. The document provides a benchmark showing single commands getting 17k requests/second while pipelined commands achieve 260k requests/second. It also demonstrates how to simulate network latency using Toxiproxy to throttle connections and see even larger gains from pipelining when there is network overhead. The RedPipe library is introduced as a way to pipeline commands while still maintaining a familiar API and handling responses with futures to avoid blocking.

EDA Governance Model: a multicloud approach based on GitOps | Alejandro Alija...HostedbyConfluent

This document discusses Galeo's EDA governance model based on GitOps for multi-cloud environments. The model defines a standardized platform and service catalogue using a unified documentation model consolidated in Git repositories. This allows governance procedures like project approval, infrastructure provisioning, and component deployment to be automated through a single CI/CD pipeline without additional documentation overhead. The catalogue is kept up-to-date based on what is actually deployed, facilitating reuse and standardization across projects.

Using Kafka as a Database For Real-Time Transaction Processing | Chad Preisle...HostedbyConfluent

You have learned about Kafka event sourcing with streams and using Kafka as a database, but you may be having a tough time wrapping your head around what that means and what challenges you will face. Kafka’s exactly once semantics, data retention rules, and stream DSL make it a great database for real-time transaction processing. This talk will focus on how to use Kafka events as a database. We will talk about using KTables vs GlobalKTables, and how to apply them to patterns we use with traditional databases. We will go over a real-world example of joining events against existing data and some issues to be aware of. We will finish covering some important things to remember about state stores, partitions, and streams to help you avoid problems when your data sets become large.

Lessons from the field: Catalog of Kafka Deployments | Joseph Niemiec, ClouderaHostedbyConfluent

Streaming architectures have been on the rise steadily and as a result, we have seen the adoption of Kafka go up too. With the diverse spread of use cases across multiple industries, we have seen a variety of Kafka deployments across our hundreds of Kafka customers. Along the way, we have learnt some best practices as well as what not to do in mission-critical architectures. Join Joe Niemiec, Sr. Product Manager at Cloudera, as he shares these insights in this session that covers topics such as - The many ways that Kafka has been deployed in the field Standalone clusters, multiple clusters in a single data center and multiple clusters geographically distributed performing replication Clusters of all sizes small and large, few messages to hundreds of thousands per second Discussion about architecture failure domains Configurations tuned and used in specific deployments

Operating Kafka on AutoPilot mode @ DBS Bank (Arpit Dubey, DBS Bank) Kafka Su...confluent

Kafka is among the few cool technologies that play a pivotal role in the digital journey of DBS to become one of the best bank in the world. Kafka is the foundation for our vision of application modernisation by: - making our systems event-driven - moving batch workloads to real-time - serving various financial industry use-cases that warrants proactive actions i.e Fraud detection, Anomaly and unusual behaviour detections. To realize our Digital vision and to keep up with the pace of this transformation, we decided to run Kafka ""as-a-self-managed-service"" at large scale. This requires minimising reliance on human operators/ engineers and have intelligent apps make all important operation related decisions. In this session, I would like to deep-dive into these intelligent apps that not only helped us maintain 100% availability but also provides self-service experience and a truly democratised Kafka ecosystem for our community. Some of these apps include : 1. Self-service on-boarding and stream discovery built by esp. leveraging Kafka admin API 2. AI Ops - using machine learning for predicting resource utilisation and early anomaly detection 3. Automated Cluster scaling, deployment and maintenance 4. Self-healing services 5. Intelligent Chaos engineering - to make apps ready for production 6. Black box Kafka monitoring 7. Load simulator for performance testing - to bring production like experience in development environments 8. Automatic tiering and streams archival - to meet several regulatory compliance and to make brokers lightweight

Serhiy Kalinets "Embracing architectural challenges in the modern .NET world"Fwdays

For more than decade .NET has been used primarily in enterprise software development. We all remember intranet deployment, IIS, SQL Server, N-tier applications and so on. The toolset (Visual Studio, SQL Management Studio, IIS Management snap-in etc) seemed to be set in stone as well as architecture (controllers, services, repositories). .NET people were isolated from other folks, who were using clusters, containers, clouds, and Linux. However, adoption of clouds during few past years, the release of .NET Core made much more choices available to developers. It turned out that traditional way of building application is not that efficient from many viewpoints, including costs, time, performance or robustness. It happens because the environment has been changed and many assumptions are not still relevant. In this talk, we will discuss what and why has been changed and how to deal with that. What are new requirements for our applications? What are new services available, and how to use them wisely? And finally, how should we design our applications to be cost-effective, competitive and have a lot of fun working with .NET Core.

.NET Cloud-Native Bootcamp- Los AngelesVMware Tanzu

More Related Content

What's hot (20)