在 go 中实现 Keycloak 领域的多租户，并为每个租户提供一个 Keycloak 实例

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《在 go 中实现 Keycloak 领域的多租户，并为每个租户提供一个 Keycloak 实例》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

目前，我正在尝试通过为每个租户使用一个 keycloak 领域，在 oauth2 安全应用程序中实现多租户。我正在用 go 创建一个原型，但并没有真正绑定到该语言，如果需要的话可以切换到 node.js 或 java。我认为如果我切换语言，我的以下问题将成立。

起初，实施多租户对我来说似乎非常简单：

• 对于每个租户，使用后端应用程序所需的客户端配置创建一个领域。
• 后端收到 url 为 tenant-1.my-app.com 的请求。解析该 url 以检索用于身份验证的租户。
• 连接到 oauth2 提供商（本例中为 keycloak）并验证请求令牌。

按照指南，我使用 golang.org/x/oauth2 和 github.com/coreos/go-oidc。这是我为单个领域设置 oauth 2 连接的方法：

provider, err := oidc.NewProvider(context.Background(), "http://keycloak.docker.localhost/auth/realms/tenant-1")
if err != nil {
    panic(err)
}

oauth2Config := oauth2.Config{
    ClientID:     "my-app",
    ClientSecret: "my-app-secret",
    RedirectURL:  "http://tenant-1.my-app.com/auth-callback",
    Endpoint: provider.Endpoint(),
    Scopes: []string{oidc.ScopeOpenID, "profile", "email"},
}
state := "somestate"

verifier := provider.Verifier(&oidc.Config{
    ClientID: "my-app",
})

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    tenant, err := getTenantFromRequest(r)
    if err != nil {
        log.Println(err)
        w.WriteHeader(400)
        return
    }
    log.Printf("Received request for tenant %s\n", tenant)

    // Check if auth is present
    rawAccessToken := r.Header.Get("Authorization")
    if rawAccessToken == "" {
        log.Println("No Auth present, redirecting to auth code url...")
        http.Redirect(w, r, oauth2Config.AuthCodeURL(state), http.StatusFound)
        return
    }

    // Check if auth is valid
    parts := strings.Split(rawAccessToken, " ")
    if len(parts) != 2 {
        w.WriteHeader(400)
        return
    }
    _, err = verifier.Verify(context.Background(), parts[1])
    if err != nil {
        log.Printf("Error during auth verification (%s), redirecting to auth code url...\n", err)
        http.Redirect(w, r, oauth2Config.AuthCodeURL(state), http.StatusFound)
        return
    }

    // Authentication okay

    w.WriteHeader(200)
})

log.Printf("Starting server (%s)...\n", proxyConfig.Url)
log.Fatal(http.ListenAndServe(proxyConfig.Url, nil))

这工作正常，但现在下一步是添加多租户。 imo 似乎我需要为每个租户创建一个 oidc.provider ，因为需要在 provider 结构中设置领域端点（http://keycloak.docker.localhost/auth/realms/tenant-1）。

我不确定这是否是处理这种情况的正确方法。我想我会为 oidc.provider 实例添加缓存，以避免在每个请求上创建实例。但正在创建一个

解决方案

尽管这尚未在生产中完全使用，但以下是我如何设计一个解决方案的原型，我最终可能会使用该解决方案：

我假设每个 keycloak 领域都必须有一个 oidc.provider。

因此，每个领域总会有一个 oidc.idtokenverifier。

为了管理这些实例，我创建了这个界面：

// a mechanism that manages oidc.provider and idtokenverifierinterface instances
type oauth2managerinterface interface {
    getoauthproviderforkeycloakrealm(ctx context.context, tenant string) (*oidc.provider, error)
    getopenidconnectverifierforprovider(provider *oidc.provider) (idtokenverifierinterface, error)
}

// interface created to describe the oidc.idtokenverifier struct.
// this was created because the oidc modules does not define its own interface
type idtokenverifierinterface interface {
    verify(ctx context.context, rawidtoken string) (*oidc.idtoken, error)
}

然后这是将实现管理器接口的结构：

type oauth2manager struct {
    providerurl string
    clientid    string

    // maps keycloak provider urls onto oidc.provider instances
    // used internally to avoid creating a new provider on each request
    providers map[string]*oidc.provider

    // lock to be used when accessing oauth2manager.providers
    providerlock sync.mutex

    // maps oidc.provider instances onto oidc.idtokenverifier instances
    // used internally to avoid creating a new verifier on each request
    verifiers map[*oidc.provider]*oidc.idtokenverifier

    // lock to be used when accessing oauth2manager.verifiers
    verifierlock sync.mutex
}

以及实际实现该接口的函数：

func (manager *OAuth2Manager) GetProviderUrlForRealm(realm string) string {
    return fmt.Sprintf("%s/%s", manager.ProviderUrl, realm)
}

func (manager *OAuth2Manager) GetOAuthProviderForKeycloakRealm(ctx context.Context, tenant string) (*oidc.Provider, error) {
    providerUrl := manager.GetProviderUrlForRealm(tenant)

    // Check if already exists ...
    manager.providerLock.Lock()
    if provider, alreadyExists := manager.providers[providerUrl]; alreadyExists {
        manager.providerLock.Unlock()
        return provider, nil
    }

    // ... create new instance if not
    provider, err := oidc.NewProvider(ctx, providerUrl)

    if err != nil {
        manager.providerLock.Unlock()
        return nil, err
    }

    manager.providers[providerUrl] = provider
    manager.providerLock.Unlock()

    log.Printf("Created new provider for provider url %s\n", providerUrl)

    return provider, nil
}

func (manager *OAuth2Manager) GetOpenIdConnectVerifierForProvider(provider *oidc.Provider) (IDTokenVerifierInterface, error) {
    // Check if already exists ...
    manager.verifierLock.Lock()
    if verifier, alreadyExists := manager.verifiers[provider]; alreadyExists {
        manager.verifierLock.Unlock()
        return verifier, nil
    }

    // ... create new instance if not
    oidcConfig := &oidc.Config{
        ClientID: manager.ClientId,
    }

    verifier := provider.Verifier(oidcConfig)

    manager.verifiers[provider] = verifier
    manager.verifierLock.Unlock()

    log.Printf("Created new verifier for OAuth endpoint %v\n", provider.Endpoint())

    return verifier, nil
}

如果同时访问提供程序，则使用 sync.mutex 锁非常重要。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。