0Pricing
Redis Caching & Messaging (Pub/Sub, Streams) · 강의

조정 서비스로서의 Redis

서비스 검색, 구성 관리, 서비스 간 통신에 Redis를 활용하는 솔루션을 설계합니다.

조정 서비스로서의 Redis은(는) CoddyKit의 무료 Redis Caching & Messaging (Pub/Sub, Streams) 강의입니다. 이것은 4개 중 3번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Redis Caching & Messaging (Pub/Sub, Streams) 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Redis Caching & Messaging (Pub/Sub, Streams) 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Coordination in Distributed Systems

In distributed systems, multiple services work together to achieve a common goal. For these services to function smoothly, they often need to find each other, share configuration, and communicate in an organized way.

This 'orchestration' is called service coordination. Without it, services might struggle to locate their dependencies, use outdated settings, or fail to process tasks efficiently.

Redis's Role in Coordination

Redis, with its speed, atomic operations, and versatile data structures, is an excellent choice for a coordination service.

  • Atomic Operations: Ensures operations are completed entirely or not at all, crucial for consistency.
  • Data Structures: Hashes, Lists, and Sets provide flexible ways to store and manage coordination data.
  • Pub/Sub: Enables real-time notification for events like configuration changes.

These features allow Redis to act as a central hub for various coordination patterns.

Understanding Service Discovery

Service discovery is how applications and microservices locate and communicate with each other on a network. In dynamic environments (like cloud deployments), service instances constantly scale up and down, and their network locations (IPs, ports) can change.

A service discovery mechanism allows services to register their presence and clients to look them up by name, rather than hardcoding addresses.

Registering Services with Redis

We can use a Redis Hash to store information about active service instances. The hash key could be 'services:<serviceName>', and fields would be '<instanceId>' mapping to '<IP:Port>'.

Try running this example to register a service instance:

import redis.clients.jedis.Jedis;

public class ServiceRegistry {
  public static void main(String[] args) {
    Jedis jedis = new Jedis("localhost"); // Connect to Redis
    String serviceName = "paymentService";
    String instanceId = "paymentsvc-001";
    String instanceAddress = "192.168.1.10:8080";

    // Register service instance
    jedis.hset("services:" + serviceName, instanceId, instanceAddress);
    System.out.println("Registered " + serviceName + " instance: " + instanceAddress);

    jedis.close();
  }
}

Discovering Active Services

Once services are registered, clients or other services can query Redis to find available instances. The HGETALL command retrieves all fields and values from a hash, giving us a list of all active instances for a given service.

Run this code to discover the registered service:

import redis.clients.jedis.Jedis;
import java.util.Map;

public class ServiceDiscovery {
  public static void main(String[] args) {
    Jedis jedis = new Jedis("localhost");
    String serviceName = "paymentService";

    // Discover all instances for a service
    Map<String, String> instances = jedis.hgetAll("services:" + serviceName);

    if (instances.isEmpty()) {
      System.out.println("No instances found for " + serviceName);
    } else {
      System.out.println("Active " + serviceName + " instances:");
      for (Map.Entry<String, String> entry : instances.entrySet()) {
        System.out.println("  ID: " + entry.getKey() + ", Address: " + entry.getValue());
      }
    }
    jedis.close();
  }
}

Centralized Configuration Management

Another crucial coordination task is managing application configurations. Instead of hardcoding settings or using local files, centralized configuration management stores configurations in a single, accessible location.

This allows for dynamic updates, consistent settings across all service instances, and avoids redeployments for simple configuration changes.

Storing Configs in Redis

Redis Hashes are well-suited for storing structured application configurations. Each hash can represent the configuration for a specific application or module, with fields being individual settings.

Here's an example of setting and retrieving configuration for an application:

import redis.clients.jedis.Jedis;
import java.util.Map;

public class ConfigManager {
  public static void main(String[] args) {
    Jedis jedis = new Jedis("localhost");
    String appConfigKey = "app:myApp:config";

    // Set configuration properties
    jedis.hset(appConfigKey, "dbHost", "my-db.example.com");
    jedis.hset(appConfigKey, "dbPort", "5432");
    jedis.hset(appConfigKey, "logLevel", "INFO");
    System.out.println("Configuration updated for myApp.");

    // Retrieve all configuration
    Map<String, String> config = jedis.hgetAll(appConfigKey);
    System.out.println("Current myApp configuration:");
    for (Map.Entry<String, String> entry : config.entrySet()) {
      System.out.println("  " + entry.getKey() + ": " + entry.getValue());
    }
    jedis.close();
  }
}

Distributing Config Updates

For dynamic configuration, services need a way to be notified when settings change. While polling Redis periodically is an option, using Redis's Pub/Sub mechanism is more efficient.

When a configuration is updated, the configuration service can publish a message to a specific channel (e.g., 'config:updates'). All subscribed services would then receive this notification and could fetch the latest configuration.

Task Queues for Inter-Service Work

Redis Lists can serve as simple yet powerful task queues, allowing services to coordinate by distributing work. One service pushes tasks onto a list (LPUSH or RPUSH), and another service pulls tasks from it (RPOP or LPOP).

Using blocking pop operations like BRPOP or BLPOP, workers can wait for tasks without busy-looping, making it highly efficient.

import redis.clients.jedis.Jedis;
import java.util.List;

public class TaskConsumer {
  public static void main(String[] args) {
    Jedis jedis = new Jedis("localhost");
    String taskQueueKey = "tasks:processing";

    System.out.println("Worker started, waiting for tasks...");

    // Simulate pushing a task for the demo to ensure something is there
    jedis.lpush(taskQueueKey, "process_order_123");

    // Blockingly pop a task from the right of the list
    // 0 means wait indefinitely until a task is available
    List<String> result = jedis.brpop(0, taskQueueKey);
    if (result != null && result.size() > 1) {
      String queueName = result.get(0); // The key from which the element was popped
      String task = result.get(1);     // The popped element
      System.out.println("Received task '" + task + "' from queue '" + queueName + "'");
      // Simulate processing
      try { Thread.sleep(1000); } catch (InterruptedException e) {}
      System.out.println("Task '" + task + "' processed.");
    }
    jedis.close();
  }
}

Quick Check: Coordination Patterns

Which of the following Redis features or commands are suitable for implementing service coordination patterns in a distributed system?

Lesson Summary

In this lesson, we explored how Redis can act as a powerful coordination service for distributed systems. We covered:

  • Using Redis Hashes for dynamic service discovery, allowing services to register and be found.
  • Leveraging Redis Hashes and Strings for centralized configuration management.
  • Employing Redis Pub/Sub to facilitate dynamic configuration updates.
  • Building task queues with Redis Lists (LPUSH/BRPOP) for inter-service work distribution.

By using Redis for these patterns, you can build more resilient, scalable, and manageable distributed applications.

자주 묻는 질문

“조정 서비스로서의 Redis” 강의는 무료인가요?

네 — “조정 서비스로서의 Redis” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Redis Caching & Messaging (Pub/Sub, Streams) 강의 전체를 잠금 해제할 수 있습니다. Redis Caching & Messaging (Pub/Sub, Streams) 강의에는 총 4개의 강의가 포함되어 있습니다.

“조정 서비스로서의 Redis”에서 뭘 배우나요?

서비스 검색, 구성 관리, 서비스 간 통신에 Redis를 활용하는 솔루션을 설계합니다. 브라우저에서 직접 실행하는 실습 코드로 Redis Caching & Messaging (Pub/Sub, Streams)을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Redis Caching & Messaging (Pub/Sub, Streams)을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Redis Caching & Messaging (Pub/Sub, Streams)은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 3번째 강의입니다.

“조정 서비스로서의 Redis” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Redis Caching & Messaging (Pub/Sub, Streams) 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Redis Caching & Messaging (Pub/Sub, Streams) 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. Redis를 사용한 분산 잠금
  2. 리더 선출 패턴
  3. 조정 서비스로서의 Redis
  4. 분산 속도 제한
← Redis Caching & Messaging (Pub/Sub, Streams)(으)로 돌아가기