golang は API ゲートウェイを実装します

マイクロサービスアーキテクチャの普及とサービス数の増加に伴い、サービスのセキュリティ、信頼性、拡張性を向上させるために、時代の要求に応じたAPIゲートウェイ技術が登場しました。今日は、Golang を使用して API ゲートウェイを作成する方法について説明します。

1. Golang の使用を選択する理由

1. 同時実行パフォーマンス: Golang は当然コルーチンをサポートしているため、同時実行性の高いシナリオで効率が向上し、スループットが向上します。
2. 完全な機能: Golang には、HTTP、WebSocket などの完全なネットワーク パッケージがあり、gRPC、MQTT などの複数のプロトコルもサポートしています。
3. コードの品質: Golang は静的言語であり、その型システムによりコードの品質が保証されると同時に、エディターの補完やプロンプトなどの機能を最大限に活用して開発効率を向上させることができます。
4. クロスプラットフォーム: Golang はさまざまなプラットフォームで実行でき、デプロイも非常に簡単です。

2. API ゲートウェイの設計アイデア

API ゲートウェイを設計する前に、API ゲートウェイが何を行う必要があるかを知る必要があります。一般に、API ゲートウェイは次のことを行う必要があります:

1. ルーティング: 要求された URI に基づいて、対応するサービスに要求をルーティングします。
2. フィルタリング: リクエストを検証して認証します。
3. 負荷分散: バックエンド上のさまざまなサービス インスタンスにリクエストを分散します。
4. キャッシュ: 応答速度を向上させるために応答結果をキャッシュします。
5. モニタリング: リクエストの応答結果の統計とモニタリング。

上記の考えに従って、主に次のコンポーネントを含む単純な API ゲートウェイを設計します。

1. ルーター: リクエストを対応するサービスにルーティングする役割を果たします。
2. フィルター: リクエストの検証、認証、その他の操作を担当します。
3. 負荷分散: バックエンドのさまざまなサービス インスタンスにリクエストを分散します。
4. キャッシュ: 応答結果をキャッシュし、応答速度を向上させます。
5. モニタリング: リクエスト応答結果の統計とモニタリングを担当します。

3. API ゲートウェイの実装

次に、上記のコンポーネントを 1 つずつ実装します。

1. ルーター

ルーターを実装するには、まずルーティング項目を定義する必要があります:

type Route struct {
    Path      string
    Method    string
    Handler   http.Handler
}

Route には、ルーティング パスを保存するためのパスと、ルーティング パスを保存するためのメソッドが含まれています。 storage リクエストのメソッド タイプ。ハンドラは、リクエストを処理するためのメソッドを保存するために使用されます。

次に、ルーティング リストを保存し、リクエストを対応するプロセッサにルーティングするための Router 構造を定義します:

type Router struct {
    routes []*Route
}

func (r *Router) HandleFunc(path string, method string, handlerFunc http.HandlerFunc) {
    r.routes = append(r.routes, &Route{Path: path, Method: method, Handler: handlerFunc})
}

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    for _, route := range r.routes {
        if route.Path == req.URL.Path && route.Method == req.Method {
            route.Handler.ServeHTTP(w, req)
            return
        }
    }

    http.Error(w, "404 not found", http.StatusNotFound)
}

コードでは、リクエスト処理メソッドとルーティングを登録するための 2 つのメソッドを提供します。 http.HandleFunc に似ている必要があります。ルーティング アドレス、リクエスト メソッド、リクエスト処理メソッドをオブジェクトにバインドします。ServeHTTP はリクエストを受信した後、一致するルートを探します。見つかった場合、リクエストは対応する処理に転送されます。メソッドが見つからない場合は 404 が返されます。

次に、簡単な処理メソッドの実装を記述します。

func main() {
    router := &Router{}

    router.HandleFunc("/hello", "GET", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "hello")
    })

    http.ListenAndServe(":8080", router)
}

この処理メソッドは、アドレス /hello を持つすべての GET リクエストに対して hello を返します。

2. フィルター

WAF (Web Application Firewall) は、Web アプリケーションをさまざまな攻撃から保護するために使用される一般的に使用されるフィルターです。リクエストメソッド、リクエストヘッダー、リクエストパラメータ、その他の情報に基づいてリクエストをフィルタリングできます。ここではリクエストヘッダーをフィルターとして使用します。リクエスト ヘッダーに特定のタグが含まれている場合は、そのタグが渡されます。それ以外の場合は、無効なリクエストとみなされます。

Golang を使用してフィルターを実装するには、各リクエストに特定のタグが含まれているかどうかを確認するミドルウェアを作成する必要があります。これが含まれている場合は、引き続きリクエストを渡します。含まれていない場合は、エラーが返されます。ミドルウェアの実装にはゴリラ/マルチプレクサを使用できます。

type FilterMiddleware struct {
    next http.Handler
}

func (f *FilterMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.Header.Get("X-Auth-Token") != "magic" {
        http.Error(w, "Unauthorized request", http.StatusUnauthorized)
        return
    }

    f.next.ServeHTTP(w, r)
}

func (r *Router) RegisterMiddleware(middleware func(http.Handler) http.Handler) {
    handler := http.Handler(r)

    for _, m := range middlewareFunctions {
        handler = m(handler)
    }

    r.Handler = handler
}

コードでは、FilterMiddleware はリクエスト ヘッダーに「X-Auth-Token」タグが含まれているかどうかを確認します。含まれている場合はリクエストは渡され、そうでない場合は未承認のエラーが返されます。また、ミドルウェアを登録するための RegisterMiddleware 関数も定義します。

3. 負荷分散

負荷分散は API ゲートウェイの最も重要なコンポーネントの 1 つであり、バックエンドのさまざまなサービス インスタンスにリクエストを分散できます。これを実現するには、ポーリング、ランダム、その他のアルゴリズムを使用できます。

ここでは、負荷分散に単純なポーリング アルゴリズムを使用します。プールから次のサーバーのアドレスを選択し、そのサーバーにリクエストを転送できます。

type LoadBalancer struct {
    Pool []string
    Next int
}

func (l *LoadBalancer) Pick() string {
    if l.Next >= len(l.Pool) {
        l.Next = 0
    }

    host := l.Pool[l.Next]

    l.Next++

    return host
}

func (r *Router) HandleFunc(path string, method string, handlerFunc http.HandlerFunc) {
    l := &LoadBalancer{
        Pool: []string{"http://127.0.0.1:8081", "http://127.0.0.1:8082"},
        Next: 0,
    }

    handler := http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
        url, err := url.Parse(l.Pick())
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        proxy := httputil.NewSingleHostReverseProxy(url)
        proxy.ServeHTTP(w, req)
    })

    r.routes = append(r.routes, &Route{Path: path, Method: method, Handler: handler})
}

コードでは、サーバー プールと次に選択されるサーバーの場所を含む単純な負荷分散構造を作成しました。 pick() メソッドは、サーバー プールの長さに基づいてサーバー アドレスを選択します。 HandleFunc では、ラウンド ロビン アルゴリズムを使用してリクエストをさまざまなサーバーに転送します。

4. キャッシュ

キャッシュによりシステムのパフォーマンスが向上し、バックエンドへのリクエストの数も削減されます。 API ゲートウェイでは、リクエスト応答プロセスにキャッシュを埋め込み、リクエストをキャッシュに直接返すことで、迅速に応答を返すことができます。

type Cache struct {
    data map[string] []byte
    mutex sync.Mutex
}

func (c *Cache) Get(key string) []byte {
    c.mutex.Lock()
    defer c.mutex.Unlock()

    if value, ok := c.data[key]; ok {
        return value
    }

    return nil
}

func (c *Cache) Set(key string, value []byte) {
    c.mutex.Lock()
    defer c.mutex.Unlock()

    c.data[key] = value
}

func (r *Router) HandleFunc(path string, method string, handlerFunc http.HandlerFunc) {
    cache := &Cache{
        data: make(map[string][]byte),
    }

    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        key := r.URL.String()
        if data := cache.Get(key); data != nil {
            w.Write(data)
            return
        }

        buffer := &bytes.Buffer{}
        proxy := httputil.NewSingleHostReverseProxy(r.URL)
        proxy.ServeHTTP(buffer, r)
        cache.Set(key, buffer.Bytes())
        w.Write(buffer.Bytes())
    })

    r.routes = append(r.routes, &Route{Path: path, Method: method, Handler: handler})
}

コードでは、キャッシュ構造を作成し、リクエストを HandleFunc にキャッシュしました。同じリクエストがキャッシュに存在する場合は、結果をキャッシュから直接返すことができるため、バックエンドへのリクエストの数が減ります。

5. モニタリング

モニタリングは、システムの実行状況をより深く理解し、現在のシステムの応答速度を把握するのに役立ちます。

使用Prometheus来实现API网关的监控。我们只需记录下来每一个请求的响应时间、状态码及信息，然后将所有的数据发送到Prometheus。

var (
    apiRequestsDuration = prometheus.NewHistogramVec(prometheus.HistogramOpts{
        Name:    "api_request_duration_seconds",
        Help:    "The API request duration distribution",
        Buckets: prometheus.DefBuckets,
    }, []string{"status"})
)

type MetricMiddleware struct {
    next http.Handler
}

func (m *MetricMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    start := time.Now()

    ww := httptest.NewRecorder()

    m.next.ServeHTTP(ww, r)

    duration := time.Since(start)

    apiRequestsDuration.WithLabelValues(strconv.Itoa(ww.Code)).Observe(duration.Seconds())

    for key, values := range ww.Header() {
        for _, value := range values {
            w.Header().Add(key, value)
        }
    }

    w.WriteHeader(ww.Code)

    body := ww.Body.Bytes()

    w.Write(body)
}

func main() {
    router := &Router{}

    router.HandleFunc("/hello", "GET", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "hello")
    })

    logger := NewLoggerMiddleware(router)

    http.Handle("/metrics", prometheus.Handler())
    http.Handle("/", logger)

    service := ":8080"

    log.Printf("Server starting on %v
", service)
    log.Fatal(http.ListenAndServe(service, nil))
}

在代码中，我们定义了一个MetricMiddleware并在请求结束后统计相关时间数据，最后通过Prometheus将数据输出到Metrics监控系统中。我们还通过http.Handle将Prometheus绑定在“/metrics”路径上，方便查询。

结束语

至此，我们用Golang实现了一个简单的API网关。在实际使用中，我们还可以添加更多的功能，如熔断、限流、容错等，来提高其安全性、稳定性和可用性。

以上がgolang は API ゲートウェイを実装しますの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。