About the course
Redis is widely recognised as an exceptionally fast, versatile, and powerful open-source in-memory data structure store, essential for modern application architectures requiring high performance. Beyond simple key-value storage, Redis offers a rich set of data structures and capabilities that make it indispensable for use cases such as caching, session management, message brokering, real-time analytics, and rate limiting. This 3-day hands-on training course provides a comprehensive deep dive into Redis, offering both the essential concepts for developers interacting with and modelling data, and the critical knowledge required for administrators responsible for deploying, configuring, and operating Redis effectively in production.
The course begins by establishing a foundational understanding of Redis architecture, its place within the NoSQL and key-value database landscape, and key considerations when planning a Redis deployment. Participants will then explore the core of Redis's power: its diverse data types, including Strings, Lists, Sets, Sorted Sets, Hashes, and HyperLogLog. Practical data modelling techniques for various application scenarios will be covered, alongside how to leverage key Redis features like Publish/Subscribe for real-time messaging, Transactions for atomicity, and how to implement high-performance caches directly using Redis, providing developers with the tools to build responsive applications.
Furthermore, the course provides in-depth coverage of Redis administration and operations. Participants will gain practical experience with obtaining, installing, and configuring Redis, implementing vital replication strategies for high availability and backup, and securing their deployments through authentication and access control. The course delves into advanced operational topics, including partitioning data for horizontal scale using Redis Cluster, and a significant portion is dedicated to understanding and applying techniques for performance tuning and benchmarking to optimise Redis deployments. The course concludes with practical considerations for rolling out Redis projects and deploying and managing Redis effectively in major cloud environments like AWS and Azure, equipping attendees with the full lifecycle knowledge needed to successfully use and manage Redis in production.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Explain Redis architecture, its key-value model, and identify common use cases and deployment considerations.
- Understand and effectively utilise the various Redis data types and apply practical data modelling techniques.
- Implement key Redis features such as Publish/Subscribe and Transactions.
- Leverage Redis effectively for building high-performance caches and message brokers.
- Obtain, install, configure, and perform basic administration of a Redis instance.
- Implement robust replication and backup strategies for data durability and high availability.
- Configure and manage Redis security settings to protect data.
- Understand Redis Partitioning concepts and implement Redis Cluster for horizontal scalability.
- Understand and apply techniques for performance tuning and benchmarking, and deploy Redis in cloud environments (AWS, Azure).
-
This 3-day hands-on training course is designed for both developers and operations professionals who want to gain a deep understanding of Redis for building high-performance, scalable applications and managing reliable Redis deployments. It is ideal for:
Developers looking to leverage Redis's data structures and features for caching, messaging, data modelling, and other use cases in their applications.
System Administrators and DevOps Engineers responsible for installing, configuring, monitoring, and maintaining Redis instances and clusters.
Software Architects designing systems that require fast, in-memory data storage, caching, or message brokering.
Professionals interested in understanding Redis deployment and operational best practices, including cloud environments.
-
Participants should have:
General familiarity with programming or software development concepts.
A basic understanding of databases and the concept of key-value stores.
Basic command-line familiarity (preferably Linux) is helpful for installation and administration labs.
Understanding of networking concepts is beneficial.
This course covers both development interaction with Redis and its administration. We can customise the training to match your team's experience and needs - with more time and coverage of fundamentals for new developers, or focus purely on admin-specific topics, for instance.
-
This Redis course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Introduction to Redis Architecture
Overview of Redis and its place in the NoSQL landscape.
Understanding the Key-Value data model and its advantages.
Redis Architecture: In-memory storage, single-threaded nature (for most operations), event loop.
Common Use Cases for Redis: Caching, Session Store, Queues, Pub/Sub, Rate Limiting, Leaderboards, Geospatial.
Considerations for your own Redis deployment (use case mapping, sizing basics).
Hands-On Lab: Exploring Redis use cases and interacting with a running instance using redis-cli.
Redis Installation and Basic Configuration
Obtaining the right version of Redis (Open Source vs. other distributions/cloud).
Methods for Installing Redis (compiling from source, package managers, Docker).
Starting and Stopping the Redis server.
Understanding the Redis configuration file (redis.conf).
Basic Configuration: Ports, bindings, daemonization, logging.
Using the CONFIG command.
Administration basics using redis-cli.
Hands-On Lab: Installing Redis locally (e.g., via package manager or Docker), starting/stopping the server, modifying basic configuration, interacting via redis-cli.
Redis Keys and Data Types
Working with Redis Keys: Naming conventions, key expiration (TTL).
Introduction to Redis Data Types: Understanding the different types and when to use them.
Strings: Basic key-value operations, counters, bit operations.
Lists: Implementing queues, stacks, capped collections.
Sets: Managing unique items, set operations (union, intersection, difference).
Sorted Sets: Storing ordered unique items, range queries, leaderboards.
Hashes: Storing object-like data, working with fields and values.
Hands-On Lab: Experimenting with commands for Strings, Lists, Sets, Sorted Sets, and Hashes, implementing simple use cases for each data type.
More Data Types and Core Features
HyperLogLog: Counting unique items efficiently with probabilistic data structure.
Introduction to Publish/Subscribe (Pub/Sub): Real-time messaging.
Publishing and subscribing to channels.
Pattern matching subscriptions.
Redis Transactions: Grouping commands for atomic execution (MULTI, EXEC, WATCH).
Hands-On Lab: Implementing Pub/Sub messaging, experimenting with HyperLogLog, performing transactions using MULTI/EXEC.
Data Modelling with Redis
Choosing the right Redis data type for common application data structures.
Modelling relationships between data.
Using Redis for specific data modelling challenges.
Combining multiple data types for complex models.
Hands-On Lab: Designing Redis data models for sample application scenarios (e.g., users, products, orders, social feeds).
Building a Cache with Redis
Understanding caching strategies (Cache-aside, Write-through, etc.).
Using Redis for application caching.
Setting expiration (TTL) and eviction policies.
Monitoring cache hit/miss ratio.
Hands-On Lab: Implementing a simple cache pattern in a hypothetical application context using Redis, configuring expiration and eviction.
Using Redis as a Message Broker
Using Redis Pub/Sub for simple messaging scenarios.
Implementing work queues using Lists (LPUSH, BRPOP).
Comparing Redis messaging features to dedicated message brokers (like RabbitMQ, Kafka) and identifying appropriate use cases.
Hands-On Lab: Building a simple work queue using Redis Lists, comparing Pub/Sub and List-based messaging.
Replication
Understanding Replication: Primary-Replica architecture.
Why use Replication? (High Availability for reads, Data Redundancy).
Setting up Redis Replication.
Monitoring Replication status.
Automatic Failover with Redis Sentinel: Introduction to Sentinel, setting up a Sentinel cluster, configuring Sentinel for monitoring and failover.
Hands-On Lab: Setting up Redis Replication (1 primary, 1+ replicas), monitoring synchronisation, setting up a basic Redis Sentinel cluster and testing failover.
Partitioning with Redis Cluster
Understanding Partitioning: Distributing data across multiple nodes for horizontal scale.
Introduction to Redis Cluster: Redis's built-in solution for partitioning and high availability.
Cluster architecture (Shards, Hash Slots).
Setting up a basic Redis Cluster.
Adding and removing nodes from a cluster.
Resharding the cluster.
Client-side implications of using Redis Cluster.
Hands-On Lab: Setting up a basic Redis Cluster, adding a node, performing resharding.
Redis Security
Importance of securing your Redis deployment.
Authentication: Configuring passwords (requirepass).
Access Control Lists (ACLs): Fine-grained user permissions (commands, keys).
Binding to specific interfaces.
Using TLS/SSL for encrypted connections.
Security best practices for Redis deployments.
Hands-On Lab: Configuring passwords and basic ACLs, securing connections with TLS.
Performance Tuning and Benchmarks
Identifying performance bottlenecks in Redis.
Using the redis-benchmark tool.
Monitoring Redis performance metrics (commands per second, latency, memory usage, CPU).
Key configuration options for performance tuning (e.g., tcp-keepalive, maxclients, persistence options).
Optimising data structures and command usage.
Understanding the impact of persistence on performance.
Client-side performance considerations (pipelining, connection pooling).
Hands-On Lab: Running benchmarks, using monitoring tools to identify performance characteristics, applying minor configuration changes and observing effects.
Deploying Redis in the Cloud
Options for deploying Redis in the cloud (Self-managed vs. Managed Services).
Overview of Managed Redis services in major cloud providers:
AWS ElastiCache for Redis.
Azure Cache for Redis.
Benefits and considerations of using managed services.
Basic steps for setting up a managed Redis instance (overview).
Considerations for rolling out your Redis project to production.
Hands-On Lab: Exploring the console of a cloud provider's managed Redis service (demonstration), discussing deployment strategies.
-
Redis Official Documentation: The primary and most comprehensive source for all aspects of Redis, including commands, data types, configuration, and administration.
Redis Commands Reference: A complete list and explanation of all Redis commands.
Redis Data Types Explained: Detailed guides on how each Redis data type works and common use cases.
List of Redis Clients: Find client libraries for virtually any programming language.
Redis Administration Guide: Comprehensive guide for managing Redis instances and clusters.
Redis Replication Documentation: Detailed information on setting up and managing primary-replica replication.
AWS ElastiCache for Redis Documentation: Specific documentation for the managed Redis service on Amazon Web Services.
Azure Cache for Redis Documentation: Specific documentation for the managed Redis service on Microsoft Azure.
Trusted by
