为你的 Go Web 应用添加认证 (Authentication)

本指南将向你展示如何将 Logto 集成到你的 Go Web 应用中。

提示:

以下演示基于 Gin Web Framework 构建。你也可以通过相同的步骤将 Logto 集成到其他框架中。
Go 示例项目可在我们的 Go SDK 仓库中找到。

前提条件

一个 Logto Cloud 账户或一个自托管 Logto。
一个已创建的 Logto 传统 Web 应用。

安装

在项目根目录执行：

go get github.com/logto-io/go

将 github.com/logto-io/go/client 包添加到你的应用代码中：

main.go
// main.go
package main

import (
	"github.com/gin-gonic/gin"
	// 添加依赖
	"github.com/logto-io/go/client"
)

func main() {
	router := gin.Default()
	router.GET("/", func(c *gin.Context) {
		c.String(200, "Hello Logto!")
	})
	router.Run(":3000")
}

集成

创建会话存储

在传统的 Web 应用程序中，用户认证信息会存储在用户会话中。

Logto SDK 提供了一个 Storage 接口，你可以根据你的 Web 框架实现一个 Storage 适配器，以便 Logto SDK 可以将用户认证信息存储在会话中。

备注:

我们不推荐使用基于 Cookie 的会话，因为 Logto 存储的用户认证信息可能会超过 Cookie 的大小限制。在这个例子中，我们使用基于内存的会话。你可以在生产环境中使用 Redis、MongoDB 和其他技术根据需要存储会话。

Logto SDK 中的 Storage 类型如下：

github.com/logto-io/client/storage.go
package client

type Storage interface {
	GetItem(key string) string
	SetItem(key, value string)
}

我们使用 github.com/gin-contrib/sessions 中间件作为示例来演示这个过程。

将中间件应用到应用程序中，以便我们可以在路由处理程序中通过用户请求上下文获取用户会话：

main.go
package main

import (
	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/memstore"
	"github.com/gin-gonic/gin"
	"github.com/logto-io/go/client"
)

func main() {
	router := gin.Default()

	// 在这个例子中我们使用基于内存的会话
	store := memstore.NewStore([]byte("your session secret"))
	router.Use(sessions.Sessions("logto-session", store))

	router.GET("/", func(ctx *gin.Context) {
		// 获取用户会话
		session := sessions.Default(ctx)
		// ...
		ctx.String(200, "Hello Logto!")
	})
	router.Run(":3000")
}

创建一个 session_storage.go 文件，定义一个 SessionStorage 并实现 Logto SDK 的 Storage 接口：

session_storage.go
package main

import (
	"github.com/gin-contrib/sessions"
)

type SessionStorage struct {
	session sessions.Session
}

func (storage *SessionStorage) GetItem(key string) string {
	value := storage.session.Get(key)
	if value == nil {
		return ""
	}
	return value.(string)
}

func (storage *SessionStorage) SetItem(key, value string) {
	storage.session.Set(key, value)
	storage.session.Save()
}

现在，在路由处理程序中，你可以为 Logto 创建一个会话存储：

session := sessions.Default(ctx)
sessionStorage := &SessionStorage{session: session}

初始化 LogtoClient

首先，创建一个 Logto 配置：

main.go
func main() {
	// ...
	logtoConfig := &client.LogtoConfig{
		Endpoint:  "<your-logto-endpoint>", // 例如 http://localhost:3001
		AppId:     "<your-application-id>",
		AppSecret: "<your-application-secret>",
	}
	// ...
}

提示:

你可以在管理控制台的应用详情页面找到并复制“应用密钥”：

然后，你可以为每个用户请求使用上述 Logto 配置创建一个 LogtoClient：

main.go
func main() {
	// ...

	router.GET("/", func(ctx *gin.Context) {
		// 创建 LogtoClient
		session := sessions.Default(ctx)
		logtoClient := client.NewLogtoClient(
			logtoConfig,
			&SessionStorage{session: session},
		)

		// 使用 Logto 控制主页内容
		authState := "你尚未登录此网站。:("

		if logtoClient.IsAuthenticated() {
			authState = "你已登录此网站！:)"
		}

		homePage := `<h1>Hello Logto</h1>` +
			"<div>" + authState + "</div>"

		ctx.Data(http.StatusOK, "text/html; charset=utf-8", []byte(homePage))
	})

	// ...
}

配置你的应用

在我们深入细节之前，这里是终端用户体验的快速概述。登录过程可以简化如下：

你的应用调用登录方法。
用户被重定向到 Logto 登录页面。对于原生应用，将打开系统浏览器。
用户登录并被重定向回你的应用（配置为重定向 URI）。

此认证 (Authentication) 过程遵循 OpenID Connect (OIDC) 协议，Logto 强制执行严格的安全措施以保护用户登录。
如果你有多个应用程序，可以使用相同的身份提供商 (IdP)（日志 (Logto)）。一旦用户登录到一个应用程序，当用户访问另一个应用程序时，Logto 将自动完成登录过程。

要了解有关基于重定向的登录的原理和好处的更多信息，请参阅 Logto 登录体验解释。

备注:

在以下代码片段中，我们假设你的应用程序运行在 http://localhost:3000/。

配置重定向 URI

切换到 Logto Console 的应用详情页面。添加一个重定向 URI http://localhost:3000/callback。

就像登录一样，用户应该被重定向到 Logto 以注销共享会话。完成后，最好将用户重定向回你的网站。例如，添加 http://localhost:3000/ 作为注销后重定向 URI 部分。

然后点击“保存”以保存更改。

处理重定向

当用户在 Logto 登录页面成功登录后，Logto 将把用户重定向到重定向 URI。

由于重定向 URI 是 http://localhost:3000/callback，我们添加 /callback 路由来处理登录后的回调。

main.go
func main() {
	// ...

	// 添加一个路由来处理登录回调请求
	router.GET("/callback", func(ctx *gin.Context) {
		session := sessions.Default(ctx)
		logtoClient := client.NewLogtoClient(
			logtoConfig,
			&SessionStorage{session: session},
		)

		// 登录回调请求由 Logto 处理
		err := logtoClient.HandleSignInCallback(ctx.Request)
		if err != nil {
			ctx.String(http.StatusInternalServerError, err.Error())
			return
		}

		// 跳转到开发者指定的页面。
		// 本例将用户带回主页。
		ctx.Redirect(http.StatusTemporaryRedirect, "/")
	})

	// ...
}

在配置好重定向 URI 后，我们添加一个 sign-in 路由来处理登录请求，并在主页上添加一个登录链接：

main.go
func main() {
	// ...

	// 在主页上添加一个链接以执行登录请求
	router.GET("/", func(ctx *gin.Context) {
		// ...
		homePage := `<h1>Hello Logto</h1>` +
			"<div>" + authState + "</div>" +
			// 添加链接
			`<div><a href="/sign-in">Sign In</a></div>`

		ctx.Data(http.StatusOK, "text/html; charset=utf-8", []byte(homePage))
	})

	// 添加一个路由来处理登录请求
	router.GET("/sign-in", func(ctx *gin.Context) {
		session := sessions.Default(ctx)
		logtoClient := client.NewLogtoClient(
			logtoConfig,
			&SessionStorage{session: session},
		)

		// 登录请求由 Logto 处理。
		// 用户登录后将被重定向到重定向 URI。
		signInUri, err := logtoClient.SignIn("http://localhost:3000/callback")
		if err != nil {
			ctx.String(http.StatusInternalServerError, err.Error())
			return
		}

		// 将用户重定向到 Logto 登录页面。
		ctx.Redirect(http.StatusTemporaryRedirect, signInUri)
	})

	// ...
}

现在，当用户访问 http://localhost:3000/sign-in 时，用户将被重定向到 Logto 登录页面。

实现登出路由

与登录流程类似，当用户登出时，Logto 将会重定向用户到登出后的重定向 URI。

现在，让我们添加 sign-out 路由来处理登出请求，并在主页上添加一个登出链接：

main.go
func main() {
	// ...

	// 在主页上添加一个链接以执行登出请求
	router.GET("/", func(ctx *gin.Context) {
		// ...
		homePage := `<h1>Hello Logto</h1>` +
			"<div>" + authState + "</div>" +
			`<div><a href="/sign-in">Sign In</a></div>` +
			// 添加链接
			`<div><a href="/sign-out">Sign Out</a></div>`

		ctx.Data(http.StatusOK, "text/html; charset=utf-8", []byte(homePage))
	})

	// 添加一个路由来处理登出请求
	router.GET("/sign-out", func(ctx *gin.Context) {
		session := sessions.Default(ctx)
		logtoClient := client.NewLogtoClient(
			logtoConfig,
			&SessionStorage{session: session},
		)

		// 登出请求由 Logto 处理。
		// 用户登出后将被重定向到登出后的重定向 URI。
		signOutUri, signOutErr := logtoClient.SignOut("http://localhost:3000")

		if signOutErr != nil {
			ctx.String(http.StatusOK, signOutErr.Error())
			return
		}

		ctx.Redirect(http.StatusTemporaryRedirect, signOutUri)
	})

	// ...
}

用户发起登出请求后，Logto 将清除会话中的所有用户认证信息。

检查点：测试你的应用程序

现在，你可以测试你的应用程序：

运行你的应用程序，你将看到登录按钮。
点击登录按钮，SDK 将初始化登录过程并将你重定向到 Logto 登录页面。
登录后，你将被重定向回你的应用程序，并看到登出按钮。
点击登出按钮以清除令牌存储并登出。

获取用户信息

显示用户信息

要显示用户的信息，你可以使用 client.GetIdTokenClaims 方法。例如，添加一个路由：

main.go
func main() {
    //...

    router.GET("/user-id-token-claims", func(ctx *gin.Context) {
      session := sessions.Default(ctx)
      logtoClient := client.NewLogtoClient(logtoConfig, &SessionStorage{session: session})

      idTokenClaims, err := logtoClient.GetIdTokenClaims()

      if err != nil {
        ctx.String(http.StatusOK, err.Error())
      }

      ctx.JSON(http.StatusOK, idTokenClaims)
    })
}

请求额外的声明 (claims)

你可能会发现从 client.GetIdTokenClaims() 返回的对象中缺少一些用户信息。这是因为 OAuth 2.0 和 OpenID Connect (OIDC) 的设计遵循最小权限原则 (PoLP)，而 Logto 是基于这些标准构建的。

默认情况下，返回的声明（Claim）是有限的。如果你需要更多信息，可以请求额外的权限（Scope）以访问更多的声明（Claim）。

信息:

“声明（Claim）”是关于主体的断言；“权限（Scope）”是一组声明。在当前情况下，声明是关于用户的一条信息。

以下是权限（Scope）与声明（Claim）关系的非规范性示例：

提示:

“sub” 声明（Claim）表示“主体（Subject）”，即用户的唯一标识符（例如用户 ID）。

Logto SDK 将始终请求三个权限（Scope）：openid、profile 和 offline_access。

要请求额外的权限 (scopes)，你可以将权限传递给 LogtoConfig 对象。例如：

main.go
logtoConfig := &client.LogtoConfig{
  // ...other configs
  Scopes: []string{"email", "phone"},
}

然后你可以在 client.GetIdTokenClaims() 的返回值中访问额外的声明：

idTokenClaims, error := client.GetIdTokenClaims()
// 现在你可以访问额外的声明 `claims.email`，`claims.phone` 等。

需要网络请求的声明

为了防止 ID 令牌 (ID token) 过大，一些声明需要通过网络请求来获取。例如，即使在权限中请求了 custom_data 声明，它也不会包含在用户对象中。要访问这些声明，你可以使用 client.FetchUserInfo() 方法：

userInfo, error := client.FetchUserInfo()
// 现在你可以访问声明 `userInfo.custom_data`

该方法将通过请求 userinfo 端点来获取用户信息。要了解更多可用的权限和声明，请参阅权限和声明部分。

权限和声明

Logto 使用 OIDC 权限和声明约定来定义从 ID 令牌和 OIDC 用户信息端点检索用户信息的权限和声明。“权限”和“声明”都是 OAuth 2.0 和 OpenID Connect (OIDC) 规范中的术语。

以下是支持的权限（Scopes）及其对应的声明（Claims）列表：

openid

声明名称	类型	描述	需要用户信息吗？
sub	`string`	用户的唯一标识符	否

profile

声明名称	类型	描述	需要用户信息吗？
name	`string`	用户的全名	否
username	`string`	用户名	否
picture	`string`	终端用户的个人资料图片的 URL。此 URL 必须指向一个图像文件（例如，PNG、JPEG 或 GIF 图像文件），而不是包含图像的网页。请注意，此 URL 应特别引用适合在描述终端用户时显示的终端用户的个人资料照片，而不是终端用户拍摄的任意照片。	否
created_at	`number`	终端用户创建的时间。时间表示为自 Unix 纪元（1970-01-01T00:00:00Z）以来的毫秒数。	否
updated_at	`number`	终端用户信息最后更新的时间。时间表示为自 Unix 纪元（1970-01-01T00:00:00Z）以来的毫秒数。	否

其他标准声明包括 family_name、given_name、middle_name、nickname、preferred_username、profile、website、gender、birthdate、zoneinfo 和 locale 也将包含在 profile 权限中，而无需请求用户信息端点。与上述声明的区别在于，这些声明只有在其值不为空时才会返回，而上述声明在值为空时将返回 null。

备注:

与标准声明不同，created_at 和 updated_at 声明使用毫秒而不是秒。

email

声明名称	类型	描述	需要用户信息吗？
email	`string`	用户的电子邮件地址	否
email_verified	`boolean`	电子邮件地址是否已验证	否

phone

声明名称	类型	描述	需要用户信息吗？
phone_number	`string`	用户的电话号码	否
phone_number_verified	`boolean`	电话号码是否已验证	否

address

请参阅 OpenID Connect Core 1.0 以获取地址声明的详细信息。

custom_data

声明名称	类型	描述	需要用户信息吗？
custom_data	`object`	用户的自定义数据	是

identities

声明名称	类型	描述	需要用户信息吗？
identities	`object`	用户的关联身份	是
sso_identities	`array`	用户的关联 SSO 身份	是

urn:logto:scope:organizations

声明名称	类型	描述	需要用户信息吗？
organizations	`string[]`	用户所属的组织 ID	否
organization_data	`object[]`	用户所属的组织数据	是

urn:logto:scope:organization_roles

声明名称	类型	描述	需要用户信息吗？
organization_roles	`string[]`	用户所属的组织角色，格式为 `<organization_id>:<role_name>`	否

考虑到性能和数据大小，如果“需要用户信息吗？”为“是”，则表示声明不会显示在 ID 令牌中，而会在用户信息端点响应中返回。

API 资源和组织

我们建议首先阅读 🔐 基于角色的访问控制 (RBAC)，以了解 Logto RBAC 的基本概念以及如何正确设置 API 资源。

配置 Logto 客户端

一旦你设置了 API 资源，就可以在应用中配置 Logto 时添加它们：

logtoConfig := &client.LogtoConfig{
    // ...other configs
    Resources: []string{"https://shopping.your-app.com/api", "https://store.your-app.com/api"},
}

每个 API 资源都有其自己的权限（权限）。

例如，https://shopping.your-app.com/api 资源具有 shopping:read 和 shopping:write 权限，而 https://store.your-app.com/api 资源具有 store:read 和 store:write 权限。

要请求这些权限，你可以在应用中配置 Logto 时添加它们：

logtoConfig := &client.LogtoConfig{
    // ...other configs
    Scopes:    []string{"shopping:read", "shopping:write", "store:read", "store:write"},
    Resources: []string{"https://shopping.your-app.com/api", "https://store.your-app.com/api"},
}

你可能会注意到权限是与 API 资源分开定义的。这是因为 OAuth 2.0 的资源指示器指定请求的最终权限将是所有目标服务中所有权限的笛卡尔积。

因此，在上述情况下，权限可以从 Logto 中的定义简化，两个 API 资源都可以拥有 read 和 write 权限，而无需前缀。然后，在 Logto 配置中：

logtoConfig := &client.LogtoConfig{
    // ...other configs
    Scopes:    []string{"read", "write"},
    Resources: []string{"https://shopping.your-app.com/api", "https://store.your-app.com/api"},
}

对于每个 API 资源，它将请求 read 和 write 权限。

备注:

请求 API 资源中未定义的权限是可以的。例如，即使 API 资源没有可用的 email 权限，你也可以请求 email 权限。不可用的权限将被安全地忽略。

成功登录后，Logto 将根据用户的角色向 API 资源发布适当的权限。

获取 API 资源的访问令牌

要获取特定 API 资源的访问令牌 (access token)，你可以使用 获取访问令牌 (GetAccessToken) 方法：

accessToken, error := logtoClient.GetAccessToken("https://shopping.your-app.com/api")

此方法将返回一个 JWT 访问令牌 (access token)，当用户具有相关权限时，可以用来访问 API 资源。如果当前缓存的访问令牌 (access token) 已过期，此方法将自动尝试使用刷新令牌 (refresh token) 获取新的访问令牌 (access token)。

获取组织令牌

如果你对组织不熟悉，请阅读 🏢 组织（多租户）以开始了解。

在配置 Logto 客户端时，你需要添加 core.UserScopeOrganizations 权限：

logtoConfig := &client.LogtoConfig{
    // ...other configs
    Scopes: []string{core.UserScopeOrganizations},
}

用户登录后，你可以获取用户的组织令牌：

// 将参数替换为有效的组织 ID。
// 用户的有效组织 ID 可以在 ID 令牌声明 `organizations` 中找到。
accessToken, error := logtoClient.GetOrganizationToken("organization-id")

// 或者
accessTokenClaims, error := logtoClient.GetOrganizationTokenClaims("organization-id")

组织 API 资源

要获取组织中 API 资源的访问令牌 (Access token)，你可以使用 getAccessToken 方法，并将 API 资源和组织 ID 作为参数：

accessToken, error := client.GetAccessToken(
  'https://shopping.your-app.com/api',
  organizationId
);

延伸阅读

终端用户流程：认证流程、账户流程和组织流程配置连接器保护你的 API

前提条件​

安装​

集成​

创建会话存储​

初始化 LogtoClient​

配置你的应用​

关于基于重定向的登录​

配置重定向 URI​

处理重定向​

实现登录路由​

实现登出路由​

检查点：测试你的应用程序​

获取用户信息​

显示用户信息​

请求额外的声明 (claims)​

需要网络请求的声明​

权限和声明​

API 资源和组织​

配置 Logto 客户端​

获取 API 资源的访问令牌​

获取组织令牌​

组织 API 资源​

延伸阅读​