Melaksanakan pengurusan konfigurasi teragih menggunakan rangka kerja web Golang rangka kerja Iris

Dengan perkembangan pesat dan populariti Internet, semakin banyak syarikat dan individu telah mula membangun dan menyelenggara pelbagai aplikasi web. Aplikasi ini biasanya perlu digunakan dan dijalankan dalam persekitaran yang berbeza, seperti persekitaran pengeluaran, persekitaran ujian, persekitaran pembangunan, dsb. Dalam persekitaran yang berbeza ini, konfigurasi aplikasi mungkin berbeza-beza, dan konfigurasi ini mungkin perlu diselaraskan dan dikemas kini secara berterusan untuk memenuhi keperluan perniagaan dan keperluan pengguna. Oleh itu, pengurusan konfigurasi telah menjadi isu yang sangat penting.

Pengurusan konfigurasi boleh dianggap sebagai sejenis pengurusan data, yang terutamanya melibatkan cara menyimpan, mendapatkan dan mengubah suai data konfigurasi. Untuk melaksanakan sistem pengurusan konfigurasi yang boleh dipercayai dan cekap, kami boleh menggunakan alat pengurusan konfigurasi teragih seperti etcd atau consul. Alat ini boleh menyediakan ciri seperti ketersediaan tinggi, ketekalan data dan toleransi kesalahan, serta sistem storan kv yang kompleks, memberikan sokongan kukuh untuk pengurusan konfigurasi kami.

Dalam artikel ini, kami memperkenalkan terutamanya cara menggunakan rangka kerja web Golang Iris untuk melaksanakan pengurusan konfigurasi teragih. Iris ialah rangka kerja Web berprestasi tinggi dan mudah digunakan yang menyokong mod MVC, pengurusan penghalaan, suntikan pergantungan dan banyak fungsi lain. Ia juga mengandungi beberapa pakej, seperti konfigurasi, sesi dan logger, yang boleh memudahkan pengurusan konfigurasi, pengurusan sesi dan operasi pengelogan. Di sini, kami akan menggunakan Iris untuk melaksanakan sistem pengurusan konfigurasi mudah yang boleh mendapatkan dan mengubah suai data konfigurasi dalam kedai KV yang diedarkan dan mengemas kininya ke pelayan lain.

Pertama, kita perlu memasang alat Iris dan etcd-cli. Memandangkan Iris bergantung pada perpustakaan standard bahasa Go, kami perlu memasang persekitaran bahasa Go terlebih dahulu. Seterusnya, kita boleh menggunakan alat baris arahan Go untuk memasang Iris:

go get -u github.com/kataras/iris

Begitu juga, kita juga perlu memasang alat etcd-cli supaya kita boleh menguruskan kluster etcd dalam baris arahan. Binari boleh dimuat turun dan digunakan terus dalam penyelesaian rasmi etcd:

wget https://github.com/etcd-io/etcd/releases/download/v3.5.0/etcd-v3.5.0-linux-amd64.tar.gz
tar xzf etcd-v3.5.0-linux-amd64.tar.gz
cd etcd-v3.5.0-linux-amd64

Seterusnya, kita boleh menjalankan kluster etcd dan menambah beberapa pasangan nilai kunci kepadanya. Perkhidmatan etcd boleh dimulakan menggunakan arahan berikut:

./etcd --name node1 --initial-advertise-peer-urls http://127.0.0.1:2380 
  --listen-peer-urls http://127.0.0.1:2380 
  --listen-client-urls http://127.0.0.1:2379,http://127.0.0.1:4001 
  --advertise-client-urls http://127.0.0.1:2379,http://127.0.0.1:4001 
  --initial-cluster-token etcd-cluster-1 
  --initial-cluster node1=http://127.0.0.1:2380,node2=http://127.0.0.1:2381,node3=http://127.0.0.1:2382 
  --initial-cluster-state new

Di sini, kami telah memulakan kluster etcd dengan 3 nod dan salah satu nod (node1) sebagai ketua. Nod berkomunikasi antara satu sama lain melalui port 2380, dan klien etcd boleh menyambung ke nod melalui port 2379 atau port 4001. Penerangan terperinci tentang parameter ini boleh didapati dalam dokumentasi rasmi dll.

Seterusnya, kita boleh menggunakan alat etcd-cli untuk menambah beberapa pasangan nilai kunci pada storan yang diedarkan. Sebagai contoh, kita boleh menambah direktori bernama "app_config", yang mengandungi beberapa data konfigurasi:

./etcdctl --endpoints http://127.0.0.1:2379 put /app_config/database_url "mysql://root:123456@localhost:3306/test_db"

Ini akan menambah sekeping data pada kluster etcd, di mana "/app_config/database_url" adalah kuncinya, Dan "mysql://root:123456@localhost:3306/test_db" ialah nilai. Data ini boleh diakses dan diubah suai pada mana-mana nod, membolehkan pengurusan konfigurasi teragih.

Kini, kami boleh mula menggunakan rangka kerja Iris untuk membina sistem pengurusan konfigurasi kami. Pertama, kita perlu merujuk rangka kerja Iris dan perpustakaan etcd dalam program, dan mencipta aplikasi Iris:

package main

import (
    "context"
    "github.com/coreos/etcd/client"
    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/logger"
    "github.com/kataras/iris/v12/middleware/recover"
)

var app *iris.Application
var etcdEndpoints []string

func main() {
    app = iris.New()
    app.Use(recover.New())
    app.Use(logger.New())
    app.Get("/config", getConfigHandler)
    app.Put("/config", updateConfigHandler)
    app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed))
}

Di sini, kami menetapkan peraturan penghalaan aplikasi Iris, di mana "/config" mendapat dan mengemas kini Antara muka API untuk data konfigurasi. Kami juga menggunakan dua middleware, satu untuk pemulihan ralat dan satu untuk pengelogan. Perisian tengah ini boleh membantu kami mengoptimumkan prestasi dan kebolehpercayaan aplikasi kami.

Seterusnya, kita perlu mencipta klien etcd untuk dapat menyambung ke kluster etcd dan melaksanakan pengurusan konfigurasi. Anda boleh menggunakan kod berikut untuk mencipta klien etcd:

    etcdEndpoints = []string{"http://127.0.0.1:2379"}

    cfg := client.Config{
        Endpoints: etcdEndpoints,
    }
    etcdClient, err := client.New(cfg)
    if err != nil {
        panic(err)
    }

Di sini, kami menentukan alamat kluster etcd dan menggunakan client.Config untuk memulakan klien etcd. Kami juga boleh menetapkan pilihan konfigurasi lain seperti sijil TLS, nama pengguna dan kata laluan, dsb.

Kini, kami boleh melaksanakan logik getConfigHandler dan updateConfigHandler untuk mendapatkan dan mengemas kini data konfigurasi dengan mudah. Pelaksanaan getConfigHandler adalah seperti berikut:

func getConfigHandler(ctx iris.Context) {
    key := ctx.URLParam("key")
    if key == "" {
        ctx.StatusCode(iris.StatusBadRequest)
        ctx.JSON(map[string]string{
            "error": "missing key parameter",
        })
        return
    }

    api := client.NewKeysAPI(etcdClient)
    resp, err := api.Get(context.Background(), key, nil)
    if err != nil {
        ctx.StatusCode(iris.StatusInternalServerError)
        ctx.JSON(map[string]string{
            "error": err.Error(),
        })
        return
    }

    ctx.StatusCode(iris.StatusOK)
    ctx.JSON(resp.Node.Value)
}

Di sini, kita mula-mula mendapatkan kunci konfigurasi yang akan diperolehi daripada parameter URL, dan kemudian menggunakan KeysAPI etcd untuk mendapatkan data konfigurasi. Jika kunci yang sepadan tidak ditemui, respons dengan kod status 400 yang mengandungi maklumat ralat dikembalikan. Jika data berjaya diperoleh, respons dengan kod status 200 dikembalikan, yang mengandungi nilai yang sepadan dengan kunci. Pelaksanaan

updateConfigHandler adalah seperti berikut:

func updateConfigHandler(ctx iris.Context) {
    key := ctx.URLParam("key")
    value := ctx.URLParam("value")
    if key == "" || value == "" {
        ctx.StatusCode(iris.StatusBadRequest)
        ctx.JSON(map[string]string{
            "error": "missing key or value parameter",
        })
        return
    }

    api := client.NewKeysAPI(etcdClient)
    _, err := api.Set(context.Background(), key, value, nil)
    if err != nil {
        ctx.StatusCode(iris.StatusInternalServerError)
        ctx.JSON(map[string]string{
            "error": err.Error(),
        })
        return
    }

    ctx.StatusCode(iris.StatusOK)
    ctx.JSON(map[string]string{
        "status": "success",
    })
}

Di sini, kami mendapat kunci dan nilai konfigurasi untuk dikemas kini daripada parameter URL. Kemudian, kami menggunakan KeysAPI etcd untuk menetapkan nilai kepada kunci yang ditentukan. Jika kemas kini berjaya, respons dengan kod status 200 dan data JSON yang mengandungi kunci "status" dikembalikan.

Akhir sekali, kita perlu menjalankan aplikasi dan menggunakan alatan seperti curl untuk menguji tindak balas antara muka API. Aplikasi boleh dimulakan menggunakan arahan berikut:

go run main.go

Kami boleh menggunakan curl untuk menguji antara muka API kami. Sebagai contoh, kita boleh menggunakan arahan berikut untuk mendapatkan data konfigurasi:

curl http://localhost:8080/config?key=/app_config/database_url

Ini akan mengembalikan respons JSON berikut:

"mysql://root:123456@localhost:3306/test_db"

Kami juga boleh menggunakan arahan berikut untuk mengemas kini data konfigurasi:

curl -X PUT -d "value=postgresql://user:password@localhost/dbname" http://localhost:8080/config?key=/app_config/database_url

Ini akan menukar nilai kekunci "/app_config/database_url" kepada "postgresql://user:password@localhost/dbname". Jika kemas kini berjaya, respons JSON berikut akan dikembalikan:

{"status":"success"}

到这里，我们已经实现了一个简单的分布式配置管理系统，该系统可以方便地获取和修改分布式KV存储中的配置数据。我们使用了Iris框架的路由、中间件和JSON响应等功能，以及etcd的KeysAPI来管理分布式存储。通过这样的方式，我们可以优化我们的应用程序的可靠性和性能，并提供更好的核心功能。

当然，实际情况下，我们需要考虑更多的方面，例如数据的安全性、版本控制、配置发布和回滚等问题。但是，通过使用Iris框架和etcd工具的技术，我们可以更加容易地构建和维护分布式配置管理系统，从而更好地满足业务和用户需求。

Atas ialah kandungan terperinci Melaksanakan pengurusan konfigurasi teragih menggunakan rangka kerja web Golang rangka kerja Iris. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!