Go 언어 기반 분산 시스템 설계: 확장성과 효율성의 완벽한 조화 🚀

분산 시스템은 현대 소프트웨어 아키텍처의 핵심입니다. 대규모 데이터 처리, 고가용성, 그리고 확장성이 요구되는 오늘날의 애플리케이션 환경에서 분산 시스템의 중요성은 더욱 커지고 있습니다. 이러한 복잡한 시스템을 구축하는 데 있어 Go 언어는 탁월한 선택지로 떠오르고 있죠. 🌟

Go 언어는 Google에서 개발한 오픈소스 프로그래밍 언어로, 간결한 문법과 강력한 동시성 지원, 그리고 효율적인 메모리 관리 기능을 제공합니다. 이러한 특성들은 분산 시스템 개발에 있어 Go를 매력적인 옵션으로 만들어주고 있습니다.

이 글에서는 Go 언어를 사용하여 분산 시스템을 설계하고 구현하는 방법에 대해 심도 있게 살펴보겠습니다. 기본 개념부터 시작하여 고급 기술까지, 실제 프로젝트에 적용할 수 있는 다양한 지식을 공유하고자 합니다.

특히, 재능넷(https://www.jaenung.net)과 같은 플랫폼에서 활동하는 개발자들에게 이 글이 유용한 자료가 되길 바랍니다. 재능넷은 다양한 기술 분야의 전문가들이 모여 지식을 공유하고 거래하는 공간이니, Go 언어와 분산 시스템에 관심 있는 분들께 좋은 참고 자료가 될 것입니다.

자, 그럼 Go 언어로 구현하는 분산 시스템의 세계로 함께 떠나볼까요? 🌈

1. Go 언어와 분산 시스템: 완벽한 조화 🤝

Go 언어가 분산 시스템 개발에 특히 적합한 이유를 살펴보기 전에, 먼저 분산 시스템이 무엇인지 간단히 정의해보겠습니다.

분산 시스템이란 네트워크로 연결된 여러 컴퓨터나 노드들이 하나의 시스템처럼 동작하여 사용자에게 일관된 서비스를 제공하는 컴퓨팅 환경을 말합니다. 이러한 시스템은 대규모 데이터 처리, 고가용성, 내결함성 등을 제공하기 위해 설계됩니다.

Go 언어는 이러한 분산 시스템 개발에 있어 여러 가지 장점을 제공합니다:

동시성 지원: Go의 goroutine과 채널은 동시성 프로그래밍을 쉽고 효율적으로 만들어줍니다.
빠른 컴파일과 실행 속도: Go는 컴파일 언어이면서도 빠른 개발 속도를 제공합니다.
풍부한 표준 라이브러리: 네트워킹, 암호화 등 분산 시스템 개발에 필요한 다양한 기능을 기본적으로 제공합니다.
간결한 문법: 복잡한 시스템을 구현하면서도 코드의 가독성과 유지보수성을 높일 수 있습니다.
크로스 컴파일 지원: 다양한 환경에서의 배포가 용이합니다.

이러한 특성들로 인해 Go는 Docker, Kubernetes, etcd 등 유명한 분산 시스템 프로젝트에서 널리 사용되고 있습니다.

이제 Go 언어의 기본적인 특성을 살펴봤으니, 본격적으로 Go를 사용한 분산 시스템 설계와 구현에 대해 알아보겠습니다. 다음 섹션에서는 분산 시스템의 핵심 개념과 Go 언어로 이를 구현하는 방법에 대해 자세히 다루겠습니다. 🚀

2. 분산 시스템의 핵심 개념 🧠

분산 시스템을 설계하고 구현하기 위해서는 몇 가지 핵심 개념을 이해해야 합니다. 이 섹션에서는 이러한 개념들을 살펴보고, Go 언어로 어떻게 구현할 수 있는지 예제와 함께 설명하겠습니다.

2.1 노드와 클러스터 🖥️

노드(Node)는 분산 시스템을 구성하는 개별 컴퓨터 또는 서버를 의미합니다. 클러스터(Cluster)는 이러한 노드들의 집합을 말하죠. Go 언어에서는 각 노드를 하나의 goroutine으로 표현할 수 있습니다.


type Node struct {
    ID   string
    Addr string
}

type Cluster struct {
    Nodes []Node
}

func (c *Cluster) AddNode(node Node) {
    c.Nodes = append(c.Nodes, node)
}

func (n *Node) Start() {
    go func() {
        // 노드의 메인 로직
    }()
}

2.2 통신 프로토콜 📡

분산 시스템에서 노드 간 통신은 매우 중요합니다. Go는 네트워크 프로그래밍을 위한 강력한 표준 라이브러리를 제공합니다. gRPC나 Protocol Buffers와 같은 효율적인 통신 프로토콜을 쉽게 구현할 수 있죠.


import (
    "net"
    "encoding/gob"
)

func (n *Node) Listen() error {
    listener, err := net.Listen("tcp", n.Addr)
    if err != nil {
        return err
    }
    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        go n.handleConnection(conn)
    }
}

func (n *Node) handleConnection(conn net.Conn) {
    defer conn.Close()
    decoder := gob.NewDecoder(conn)
    var message Message
    err := decoder.Decode(&message)
    if err != nil {
        return
    }
    // 메시지 처리 로직
}

2.3 일관성과 합의 알고리즘 🤝

분산 시스템에서 데이터의 일관성을 유지하는 것은 중요한 과제입니다. 이를 위해 다양한 합의 알고리즘이 사용되는데, 그 중 대표적인 것이 Raft 알고리즘입니다. Go 언어로 Raft 알고리즘을 구현한 라이브러리들이 있어, 이를 활용할 수 있습니다.


import "github.com/hashicorp/raft"

type FSM struct {
    // 상태 머신 구현
}

func (f *FSM) Apply(log *raft.Log) interface{} {
    // 로그 적용 로직
}

func NewRaftNode(config *raft.Config, fsm *FSM) (*raft.Raft, error) {
    return raft.NewRaft(config, fsm)
}

2.4 부하 분산 ⚖️

효율적인 리소스 활용을 위해 부하 분산은 필수적입니다. Go에서는 간단한 라운드 로빈 방식부터 복잡한 알고리즘까지 다양한 부하 분산 전략을 구현할 수 있습니다.


type LoadBalancer struct {
    backends []string
    current  int
}

func (lb *LoadBalancer) NextBackend() string {
    backend := lb.backends[lb.current]
    lb.current = (lb.current + 1) % len(lb.backends)
    return backend
}

2.5 장애 허용 및 복구 🛠️

분산 시스템에서 장애는 피할 수 없습니다. 따라서 장애를 감지하고 복구하는 메커니즘이 필요합니다. Go의 채널과 select 문을 활용하면 효과적인 장애 감지 시스템을 구현할 수 있습니다.


func (n *Node) MonitorHealth(timeout time.Duration) {
    ticker := time.NewTicker(timeout)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            if !n.isHealthy() {
                go n.recover()
            }
        case <-n.stopChan:
            return
        }
    }
}

func (n *Node) recover() {
    // 복구 로직
}

이러한 핵심 개념들을 이해하고 Go 언어로 구현할 수 있다면, 견고하고 효율적인 분산 시스템을 설계할 수 있습니다. 다음 섹션에서는 이러한 개념들을 바탕으로 실제 분산 시스템 아키텍처를 설계하는 방법에 대해 알아보겠습니다. 🏗️

3. Go 언어로 분산 시스템 아키텍처 설계하기 🏗️

이제 Go 언어를 사용하여 실제 분산 시스템 아키텍처를 설계하는 방법에 대해 알아보겠습니다. 이 섹션에서는 마이크로서비스 아키텍처, 이벤트 기반 아키텍처, 그리고 데이터 파이프라인 아키텍처 등 다양한 분산 시스템 패턴을 Go로 구현하는 방법을 살펴볼 것입니다.

3.1 마이크로서비스 아키텍처 🧩

마이크로서비스 아키텍처는 대규모 애플리케이션을 작고 독립적인 서비스들로 분리하여 구성하는 방식입니다. Go 언어는 경량화된 실행 파일과 빠른 시작 시간으로 마이크로서비스 구현에 매우 적합합니다.


package main

import (
    "net/http"
    "encoding/json"
    "github.com/gorilla/mux"
)

type User struct {
    ID   string `json:"id"`
    Name string `json:"name"`
}

func GetUserHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userID := vars["id"]

    // 데이터베이스에서 사용자 정보를 가져오는 로직
    user := User{ID: userID, Name: "John Doe"}

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/users/{id}", GetUserHandler).Methods("GET")
    http.ListenAndServe(":8080", r)
}

이 예제는 사용자 정보를 제공하는 간단한 마이크로서비스를 보여줍니다. 실제 시스템에서는 여러 개의 이러한 서비스들이 서로 통신하며 전체 시스템을 구성하게 됩니다.

3.2 이벤트 기반 아키텍처 🎭

이벤트 기반 아키텍처는 시스템 컴포넌트 간의 결합도를 낮추고 확장성을 높이는 데 효과적입니다. Go의 채널과 goroutine을 활용하면 효율적인 이벤트 처리 시스템을 구축할 수 있습니다.


type Event struct {
    Type string
    Data interface{}
}

type EventBus struct {
    subscribers map[string][]chan Event
    mu          sync.RWMutex
}

func (eb *EventBus) Subscribe(eventType string) chan Event {
    eb.mu.Lock()
    defer eb.mu.Unlock()

    ch := make(chan Event, 1)
    eb.subscribers[eventType] = append(eb.subscribers[eventType], ch)
    return ch
}

func (eb *EventBus) Publish(event Event) {
    eb.mu.RLock()
    defer eb.mu.RUnlock()

    for _, ch := range eb.subscribers[event.Type] {
        go func(ch chan Event) {
            ch <- event
        }(ch)
    }
}

// 사용 예
eventBus := &EventBus{subscribers: make(map[string][]chan Event)}

// 구독
ch := eventBus.Subscribe("user_created")
go func() {
    for event := range ch {
        // 이벤트 처리 로직
        fmt.Printf("Received event: %v\n", event)
    }
}()

// 이벤트 발행
eventBus.Publish(Event{Type: "user_created", Data: User{ID: "123", Name: "Alice"}})

이 예제는 간단한 이벤트 버스 시스템을 구현한 것입니다. 실제 분산 시스템에서는 Apache Kafka나 RabbitMQ 같은 메시지 브로커를 사용하여 더 복잡하고 확장 가능한 이벤트 기반 시스템을 구축할 수 있습니다.

3.3 데이터 파이프라인 아키텍처 🚰

대규모 데이터 처리를 위한 데이터 파이프라인 아키텍처도 Go 언어로 효과적으로 구현할 수 있습니다. Go의 동시성 모델은 복잡한 데이터 흐름을 관리하는 데 매우 유용합니다.


type DataPoint struct {
    Value float64
    Time  time.Time
}

func dataGenerator(out chan<- DataPoint) {
    for {
        out <- DataPoint{
            Value: rand.Float64(),
            Time:  time.Now(),
        }
        time.Sleep(time.Second)
    }
}

func dataProcessor(in <-chan DataPoint, out chan<- DataPoint) {
    for data := range in {
        // 데이터 처리 로직
        processedData := DataPoint{
            Value: data.Value * 2,
            Time:  data.Time,
        }
        out <- processedData
    }
}

func dataSink(in <-chan DataPoint) {
    for data := range in {
        // 데이터 저장 또는 출력
        fmt.Printf("Processed data: %v\n", data)
    }
}

func main() {
    rawData := make(chan DataPoint)
    processedData := make(chan DataPoint)

    go dataGenerator(rawData)
    go dataProcessor(rawData, processedData)
    go dataSink(processedData)

    // 메인 고루틴이 종료되지 않도록
    select {}
}

이 예제는 데이터를 생성하고, 처리하고, 최종적으로 저장하는 간단한 데이터 파이프라인을 보여줍니다. 실제 시스템에서는 여러 단계의 처리 과정과 다양한 데이터 소스 및 싱크를 포함할 수 있습니다.

이러한 아키텍처 패턴들은 각각의 장단점이 있으며, 실제 시스템에서는 이들을 조합하여 사용하는 경우가 많습니다. Go 언어의 유연성과 강력한 동시성 모델 덕분에 이러한 다양한 패턴을 효과적으로 구현할 수 있습니다.

다음 섹션에서는 이러한 아키텍처를 바탕으로 실제 분산 시스템을 구현할 때 고려해야 할 주요 기술적 요소들에 대해 더 자세히 알아보겠습니다. 🔧

4. Go 언어로 분산 시스템 구현하기: 주요 기술적 요소 🛠️

분산 시스템을 실제로 구현할 때는 여러 가지 기술적 요소들을 고려해야 합니다. 이 섹션에서는 Go 언어를 사용하여 이러한 요소들을 어떻게 구현할 수 있는지 살펴보겠습니다.

4.1 서비스 디스커버리 🔍

서비스 디스커버리는 분산 시스템에서 각 서비스의 위치를 동적으로 찾아내는 메커니즘입니다. Go 언어로 구현된 etcd나 Consul과 같은 도구를 사용하여 효과적인 서비스 디스커버리 시스템을 구축할 수 있습니다.


import (
    "github.com/coreos/etcd/clientv3"
    "context"
    "time"
)

func registerService(client *clientv3.Client, serviceName, serviceAddr string) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    _, err := client.Put(ctx, "/services/"+serviceName, serviceAddr)
    return err
}

func discoverService(client *clientv3.Client, serviceName string) (string, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    resp, err := client.Get(ctx, "/services/"+serviceName)
    if err != nil {
        return "", err
    }

    if len(resp.Kvs) == 0 {
        return "", fmt.Errorf("service not found")
    }

    return string(resp.Kvs[0].Value), nil
}

4.2 로드 밸런싱 ⚖️

로드 밸런싱은 여러 서버나 서비스 인스턴스 간에 트래픽을 분산시키는 기술입니다. Go의 표준 라이브러리를 사용하여 간단한 로드 밸런서를 구현할 수 있습니다.


import (
    "net/http"
    "net/http/httputil"
    "net/url"
    "sync/atomic"
)

type LoadBalancer struct {
    backends []*url.URL
    current  uint64
}

func (lb *LoadBalancer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    backend := lb.backends[atomic.AddUint64(&lb.current, 1) % uint64(len(lb.backends))]
    httputil.NewSingleHostReverseProxy(backend).ServeHTTP(w, r)
}

func NewLoadBalancer(backends []string) (*LoadBalancer, error) {
    var urls []*url.URL
    for _, backend := range backends {
        url, err := url.Parse(backend)
        if err != nil {
            return nil, err
        }
        urls = append(urls, url)
    }
    return &LoadBalancer{backends: urls}, nil
}

4.3 분산 트랜잭션 💼

분산 트랜잭션은 여러 서비스나 데이터베이스에 걸쳐 있는 작업의 일관성을 보장하는 메커니즘입니다. Go에서는 2단계 커밋(Two-Phase Commit) 프로토콜을 구현하여 분산 트랜잭션을 관리할 수 있습니다.


type TransactionCoordinator struct {
    participants []Participant
}

type Participant interface {
    Prepare() bool
    Commit()
    Rollback()
}

func (tc *TransactionCoordinator) RunTransaction() bool {
    // 준비 단계
    for _, p := range tc.participants {
        if !p.Prepare() {
            tc.rollback()
            return false
        }
    }

    // 커밋 단계
    for _, p := range tc.participants {
        p.Commit()
    }

    return true
}

func (tc *TransactionCoordinator) rollback() {
    for _, p := range tc.participants {
        p.Rollback()
    }
}

4.4 데이터 일관성 🔄

분산 시스템에서 데이터 일관성을 유지하는 것은 중요한 과제입니다. Go에서는 분산 락이나 리더 선출 알고리즘을 구현하여 데이터 일관성을 관리할 수 있습니다. 예를 들어, etcd를 사용한 분산 락 구현은 다음과 같습니다:


import (
    "context"
    "github.com/coreos/etcd/clientv3"
    "github.com/coreos/etcd/clientv3/concurrency"
)

func acquireLock(client *clientv3.Client, lockName string) (*concurrency.Mutex, error) {
    session, err := concurrency.NewSession(client)
    if err != nil {
        return nil, err
    }

    mutex := concurrency.NewMutex(session, "/locks/"+lockName)

    if err := mutex.Lock(context.Background()); err != nil {
        return nil, err
    }

    return mutex, nil
}

func releaseLock(mutex *concurrency.Mutex) error {
    return mutex.Unlock(context.Background())
}

4.5 장애 감지 및 복구 🚨

분산 시스템에서 장애는 피할 수 없는 현실입니다. Go의 goroutine과 채널을 활용하여 효과적인 장애 감지 및 복구 시스템을 구현할 수 있습니다.


type Service struct {
    Name string
    URL  string
}

func (s *Service) Monitor(interval time.Duration, failureThreshold int) {
    failures := 0
    ticker := time.NewTicker(interval)
    defer ticker.Stop()

    for range ticker.C {
        if !s.isHealthy() {
            failures++
            if failures >= failureThreshold {
                go s.recover()
            }
        } else {
            failures = 0
        }
    }
}

func (s *Service) isHealthy() bool {
    resp, err := http.Get(s.URL + "/health")
    if err != nil {
        return false
    }
    defer resp.Body.Close()
    return resp.StatusCode == http.StatusOK
}

func (s *Service) recover() {
    // 서비스 재시작 또는 대체 인스턴스 활성화 등의 복구 로직
    log.Printf("Recovering service: %s", s.Name)
}

4.6 모니터링 및 로깅 📊

분산 시스템의 상태를 모니터링하고 문제를 진단하기 위해서는 효과적인 모니터링 및 로깅 시스템이 필수적입니다. Go 언어로 구현된 Prometheus나 Grafana와 같은 도구를 활용할 수 있습니다.


import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "net/http"
)

var (
    requestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests",
        },
        []string{"method", "endpoint"},
    )
)

func init() {
    prometheus.MustRegister(requestsTotal)
}

func instrumentHandler(handler http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        requestsTotal.With(prometheus.Labels{
            "method":   r.Method,
            "endpoint": r.URL.Path,
        }).Inc()
        handler(w, r)
    }
}

func main() {
    http.Handle("/metrics", promhttp.Handler())
    http.HandleFunc("/api", instrumentHandler(apiHandler))
    http.ListenAndServe(":8080", nil)
}

func apiHandler(w http.ResponseWriter, r *http.Request) {
    // API 로직
}

이러한 기술적 요소들을 적절히 조합하여 구현하면, Go 언어로 강력하고 확장 가능한 분산 시스템을 구축할 수 있습니다. 각 요소는 시스템의 특정 요구사항을 해결하며, 전체적으로 시스템의 안정성, 성능, 그리고 확장성을 향상시킵니다.

다음 섹션에서는 이러한 기술적 요소들을 실제 프로젝트에 적용할 때 고려해야 할 모범 사례와 주의사항에 대해 알아보겠습니다. 이를 통해 더욱 견고하고 효율적인 분산 시스템을 설계하고 구현할 수 있을 것입니다. 🚀

5. 분산 시스템 구현의 모범 사례와 주의사항 🌟

Go 언어로 분산 시스템을 구현할 때 고려해야 할 몇 가지 모범 사례와 주의사항에 대해 알아보겠습니다. 이러한 지침을 따르면 더욱 안정적이고 유지보수가 용이한 시스템을 구축할 수 있습니다.

5.1 멱등성 보장 🔄

분산 시스템에서는 네트워크 문제나 시스템 장애로 인해 동일한 요청이 여러 번 처리될 수 있습니다. 따라서 작업의 멱등성(idempotency)을 보장하는 것이 중요합니다.


type Order struct {
    ID     string
    UserID string
    Amount float64
}

func (o *Order) Process() error {
    // 주문 ID를 기반으로 중복 처리 확인
    if isAlreadyProcessed(o.ID) {
        return nil // 이미 처리된 주문은 무시
    }

    // 주문 처리 로직
    err := processOrder(o)
    if err != nil {
        return err
    }

    // 처리 완료 표시
    markAsProcessed(o.ID)
    return nil
}

5.2 우아한 성능 저하 구현 📉

시스템의 일부가 실패하더라도 전체 시스템이 완전히 중단되지 않도록 우아한 성능 저하(graceful degradation)를 구현해야 합니다.


func GetUserData(userID string) (*UserData, error) {
    userData, err := getUserFromCache(userID)
    if err == nil {
        return userData, nil
    }

    // 캐시에서 실패하면 데이터베이스에서 조회
    userData, err = getUserFromDatabase(userID)
    if err == nil {
        // 데이터베이스 조회 성공 시 캐시 업데이트
        go updateCache(userID, userData)
        return userData, nil
    }

    // 모든 시도 실패 시 기본 데이터 반환
    return getDefaultUserData(userID), nil
}

5.3 백프레셔 메커니즘 구현 🚰

시스템의 한 부분이 과부하 상태일 때 전체 시스템이 영향을 받지 않도록 백프레셔(backpressure) 메커니즘을 구현해야 합니다.


func processRequests(input <-chan Request, maxConcurrent int) {
    semaphore := make(chan struct{}, maxConcurrent)

    for request := range input {
        semaphore <- struct{}{} // 세마포어 획득
        go func(req Request) {
            defer func() { <-semaphore }() // 세마포어 반환
            processRequest(req)
        }(request)
    }
}

5.4 회로 차단기 패턴 적용 🔌

반복적인 실패를 방지하기 위해 회로 차단기(Circuit Breaker) 패턴을 적용하는 것이 좋습니다.


type CircuitBreaker struct {
    failureThreshold int
    resetTimeout     time.Duration
    failures         int
    lastFailure      time.Time
    mu               sync.Mutex
}

func (cb *CircuitBreaker) Execute(fn func() error) error {
    cb.mu.Lock()
    defer cb.mu.Unlock()

    if cb.failures >= cb.failureThreshold &&
        time.Since(cb.lastFailure) < cb.resetTimeout {
        return errors.New("circuit open")
    }

    err := fn()
    if err != nil {
        cb.failures++
        cb.lastFailure = time.Now()
        return err
    }

    cb.failures = 0
    return nil
}

5.5 적절한 타임아웃 설정 ⏱️

모든 네트워크 요청과 작업에 적절한 타임아웃을 설정하여 시스템이 무한정 대기하는 상황을 방지해야 합니다.


func fetchData(url string) ([]byte, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, err
    }

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    return ioutil.ReadAll(resp.Body)
}

5.6 적절한 로깅과 모니터링 📊

시스템의 상태를 실시간으로 파악하고 문제를 신속하게 진단할 수 있도록 적절한 로깅과 모니터링 시스템을 구축해야 합니다.


import (
    "github.com/sirupsen/logrus"
    "github.com/prometheus/client_golang/prometheus"
)

var (
    requestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "http_request_duration_seconds",
            Help:    "HTTP request latencies in seconds",
            Buckets: prometheus.DefBuckets,
        },
        []string{"method", "path"},
    )
)

func init() {
    prometheus.MustRegister(requestDuration)
}

func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        duration := time.Since(start)

        logrus.WithFields(logrus.Fields{
            "method":   r.Method,
            "path":     r.URL.Path,
            "duration": duration,
        }).Info("Request processed")

        requestDuration.WithLabelValues(r.Method, r.URL.Path).Observe(duration.Seconds())
    }
}