Cloud Datastore などの Google Cloud リソースにアクセスする際にサービスアカウントを作成することがあります。

サービスアカウントはリソースにアクセスする際に様々な認証方法を使用することができます。

そのうちのひとつが**サービスアカウントキー**で、これはユーザーがユーザー名とパスワードを使って認証するのと同じような方法です。



サービスアカウントキーは JSON ファイルとして Google Cloud からダウンロードして使用しますが、このファイルは機密情報で、扱いには注意が必要です。

また、サービスアカウントキーには有効期限がなく、キーさえあれば誰でもリソースにアクセスできてしまいます <img className="emoji" draggable="false" alt="😇" src="https://twemoji.maxcdn.com/v/13.1.0/72x72/1f607.png"/>

そのため、サービスアカウントキーの使用はセキュリティリスクが高く、[推奨されていません](https://cloud.google.com/iam/docs/best-practices-service-accounts#use-keys)。

 

**Workload Identity 連携** は、サービスアカウントの別の認証方法のひとつです。

この方法では、サービスアカウントキーのような機密情報の入ったファイルを保存することはありません。

代わりに、外部の ID プロバイダ (IdP) によって発行された認証情報を使用してリソースにアクセスをします。

使用できる IdP としては AWS や Azure などがありますが、 OpenID Connect (OIDC) や SAML をサポートする任意の IdP も使用できます。

[Auth0](https://auth0.com) は OIDC をサポートする IdP で、
SNS ログイン、パスワードレス認証、多要素認証など、様々な機能が使用できます。

この記事では、 Auth0 を用いて Workload Identity 連携を実現する方法を紹介します。

<toc />

## 認証の流れ

認証の流れを簡単に図にすると以下のようになります。

<postimage src="Diagram" alt="Diagram" />

まず、クライアントが Auth0 の Client ID と Client Secret を使って Auth0 の認証 URL にアクセスします。

Auth0 での認証が成功すると、クライアントに ID トークンが渡されます。

クライアントは受け取った ID トークンを使って、 Google Cloud リソースにアクセスすることができます。

今回の実装では、認証のために一時的にサーバを立てて、認証が終わったらサーバを落とし、
Cloud クライアントライブラリを用いて Google Cloud リソースにアクセスするアプリの処理が続くという形になっています。

次のセクションから、具体的な設定方法について説明します。

## Auth0 での設定

例として、 Go と Echo で実装をする場合のコードを載せています。

基本的には [Auth0 公式の docs](https://auth0.com/docs/quickstart/webapp/golang/interactive) のとおりに進めていきます。

### ダッシュボードでの設定

Auth0 のダッシュボードの Applications ページから、Create Application を押して、
新しいアプリケーションを作成します。

アプリケーションの種類を選択できますが、今回は Regular Web Applications を選択します。

<postimage src="Auth0 - Create application" alt="Auth0 - Create application" />

アプリケーションを作成できたら、 Settings > Application URIs から Allowed Callback URLs を設定します。

この URL は、 Auth0 の認証が成功した際にリダイレクトする URL となります。

<postimage src="Auth0 - Application Callback URLs" alt="Auth0 - Application Callback URLs" />

また、安全のため Advanced Settings > Grant Types から、 Authorization Code 以外のチェックをすべて外しておきます。

<postimage src="Grant Types" alt="Grant Types" />

初期設定では ON になっていますが、もし Client Credentials にチェックが入っていると、
Client ID と Client Secret を用いて、認証せずとも Google Cloud のリソースにアクセスできるアクセストークンを取得できてしまいます。

これでは Client ID と Client Secret がサービスアカウントキーと同じ状態になってしまうので望ましくありません。

ダッシュボード上での設定は以上となります。

### 実装

流れとしては、

- OAuth2 & OpenID Connect の設定をする
- Auth0 の認証 URL にリダイレクトし、認証をする
- 認証が成功したら Callback URL にリダイレクトする
- 取得した ID トークンを一時ファイルに保存する

となります。

次のセクションで後述しますが、Cloud クライアントライブラリが認証構成ファイルをもとにして ID トークンが記述されたファイルを読み込むため、
一時ファイルに保存する必要があるようです。

<details>
<summary>環境変数を設定する</summary>

Client ID と Client Secret は、 Application の Settings > Basic Information から取得します。

```go name=app/internal/constants/constants.go
package constants

...

const (
	AUTH_URL = "https://app.jp.auth0.com/"
	PORT = "3000"
)

var (
	AUTH0_CLIENT_ID = os.Getenv("AUTH0_CLIENT_ID")
	AUTH0_CLIENT_SECRET = os.Getenv("AUTH0_CLIENT_SECRET")
	AUTH0_CALLBACK_URL = fmt.Sprintf("http://localhost:%s/callback", PORT)
)
```

</details>

<details>
<summary>OAuth2 & OpenID Connect の設定をする</summary>

OAuth2 & OpenID Connect クライアントを返す関数と、ID トークンを検証する関数を定義します。

```go name=app/internal/auth/authenticator/authenticator.go
package authenticator

import (
	"context"
	"fmt"
	"app/internal/constants"

	"github.com/coreos/go-oidc/v3/oidc"
	"golang.org/x/oauth2"
)

// Authenticator is used to authenticate our users.
type Authenticator struct {
	*oidc.Provider
	oauth2.Config
}

// New instantiates the *Authenticator.
func New() (*Authenticator, error) {
	provider, err := oidc.NewProvider(context.Background(), constants.AUTH_URL)
	if err != nil {
		return nil, fmt.Errorf("Authenticator.New: %w", err)
	}

	conf := oauth2.Config{
		ClientID: constants.AUTH0_CLIENT_ID,
		ClientSecret: constants.AUTH0_CLIENT_SECRET,
		RedirectURL: constants.AUTH0_CALLBACK_URL,
		Endpoint: provider.Endpoint(),
		Scopes: []string{oidc.ScopeOpenID},
	}

	return &Authenticator{
		Provider: provider,
		Config: conf,
	}, nil
}

// VerifyIDToken verifies that an *oauth2.Token is a valid *oidc.IDToken.
func (a *Authenticator) VerifyIDToken(ctx context.Context, rawIDToken string) (*oidc.IDToken, error) {
	oidcConfig := &oidc.Config{
		ClientID: a.ClientID,
	}

	return a.Verifier(oidcConfig).Verify(ctx, rawIDToken)
}
```

</details>

<details>
<summary>サーバまわりの処理をかく</summary>

認証用にサーバを立て、認証が終わったらサーバを閉じるという処理を書きます。

サーバの起動を goroutine で実行し、認証の完了を待ちます。

認証が完了した後に、サーバを閉じます。

```go name=app/internal/auth/server/server.go
package server

import (
	"context"
	"fmt"
	"net/http"
	"app/internal/auth/authenticator"
	"app/internal/auth/handler"
	"app/internal/constants"
	"time"

	"github.com/gorilla/sessions"
	"github.com/labstack/echo-contrib/session"
	"github.com/labstack/echo/v4"
	"github.com/labstack/gommon/log"
)

func RunServer(auth *authenticator.Authenticator) {
	authenticated := make(chan bool, 1)

	// Setup
	e := echo.New()

	e.HideBanner = true
	e.HidePort = true

	loginURL := fmt.Sprintf("http://localhost:%s", constants.PORT)
	fmt.Printf("➡️ Visit \x1b[4m%s\x1b[m to authenticate.\n", loginURL)

	e.Use(session.Middleware(sessions.NewCookieStore([]byte("secret"))))

	e.GET("/", handler.HandleLogin(auth))
	e.GET("/callback", handler.HandleCallback(auth, authenticated))

	// Start server
	addr := fmt.Sprintf(":%s", constants.PORT)
	go func() {
		if err := e.Start(addr); err != nil && err != http.ErrServerClosed {
			e.Logger.Fatal(err)
		}
		e.Logger.Info("shutting down the server")
	}()

	// Wait for authentication completion
	<-authenticated

	// Shutdown the server
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := e.Shutdown(ctx); err != nil {
		e.Logger.Fatal(err)
	}
}
```

</details>

<details>
<summary>Auth0 の認証 URL にリダイレクトし、認証をする</summary>

ログイン URL にアクセスしたときの処理を書きます。

ここでは、`state` という値をセッションに保存し、 Auth0 の認証 URL にリダイレクトします。

`state` はランダムな文字列で、 Callback URL に戻ったときに同じ値が渡されることをチェックします。

```go name=app/internal/auth/handler/login.go
package handler

import (
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"net/http"
	"app/internal/auth/authenticator"

	"github.com/labstack/echo-contrib/session"
	"github.com/labstack/echo/v4"
)

func HandleLogin(auth *authenticator.Authenticator) echo.HandlerFunc {
	return func(c echo.Context) error {
		state, err := generateRandomState()
		if err != nil {
			return c.String(http.StatusInternalServerError, err.Error())
		}

		// Save the state inside the session.
		sess, err := session.Get("state", c)
		if err != nil {
			return c.String(http.StatusInternalServerError, err.Error())
		}

		sess.Values["state"] = state
		if err := sess.Save(c.Request(), c.Response()); err != nil {
			return c.String(http.StatusInternalServerError, err.Error())
		}

		return c.Redirect(http.StatusTemporaryRedirect, auth.AuthCodeURL(state))
	}
}

func generateRandomState() (string, error) {
	b := make([]byte, 32)
	_, err := rand.Read(b)
	if err != nil {
		return "", fmt.Errorf("generateRandomState: %w", err)
	}

	state := base64.StdEncoding.EncodeToString(b)

	return state, nil
}
```

このエンドポイント (`localhost:3000`) にアクセスすると、 Auth0 の認証画面が表示されます。

<postimage src="Auth0 login page" alt="Auth0 login page" />

ここで使用する認証方法 (パスワードレス認証、多要素認証など) は Auth0 のダッシュボードから設定できます。

</details>

<details>
<summary>認証が成功したら Callback URL にリダイレクトする</summary>

Auth0 の画面での認証が成功すると、 Callback URL にリダイレクトします。

Callback URL にアクセスしたときの処理を書きます。

ここでは `state` と ID トークンの検証を行ったあとに、ID トークンをファイルに保存します。

また、認証が完了したことを channel に通知します。

```go name=app/internal/auth/handler/callback.go
package handler

import (
	"net/http"
	"app/internal/auth/authenticator"
	"app/internal/auth/token"
	"app/internal/constants"

	"github.com/labstack/echo-contrib/session"
	"github.com/labstack/echo/v4"
)

func HandleCallback(auth *authenticator.Authenticator, authenticated chan<- bool) echo.HandlerFunc {
	return func(c echo.Context) error {
		sess, err := session.Get("state", c)
		if err != nil {
			return c.String(http.StatusInternalServerError, err.Error())
		}

		if c.QueryParam("state") != sess.Values["state"] {
			return c.String(http.StatusBadRequest, "Invalid state parameter.")
		}

		// Exchange an authorization code for a token.
		tk, err := auth.Exchange(c.Request().Context(), c.QueryParam("code"))
		if err != nil {
			return c.String(http.StatusUnauthorized, "Failed to exchange an authorization code for a token.")
		}

		rawIDToken, ok := tk.Extra("id_token").(string)
		if !ok {
			return c.String(http.StatusBadRequest, "No id_token field in oauth2 token.")
		}

		_, err = auth.VerifyIDToken(c.Request().Context(), rawIDToken)
		if err != nil {
			return c.String(http.StatusInternalServerError, "Failed to verify ID Token.")
		}

		if err := token.SaveTokenToFile(rawIDToken); err != nil {
			return c.String(http.StatusInternalServerError, "Failed to save access token.")
		}

		authenticated <- true

		return c.String(http.StatusOK, "Authentication succeeded!")
	}
}
```

注意点として、`auth.Exchange` によって得られた `tk` から `tk.AccessToken` を取得できるのですが、
これが JWE 形式のトークンで、 Cloud クライアントライブラリが使用するトークンの要件を満たさないため動作しません。

Cloud クライアントライブラリ用に使用するのは `tk.Extra("id_token")` から取得した ID トークンとなります。

</details>

<details>
<summary>取得した ID トークンを一時ファイルに保存する</summary>

ID トークンをファイルに保存したり削除したりする関数を定義します。

`tokenFilePath` のパスは、 GCP 側で設定する際に同じものを指定します。

```go name=app/internal/auth/token/token.go
package token

import (
	"fmt"
	"os"
)

const tokenFilePath = "./tmp/app-token"

func SaveTokenToFile(token string) error {
	f, err := os.Create(tokenFilePath)
	if err != nil {
		return fmt.Errorf("SaveTokenToFile: %w", err)
	}
	defer f.Close()

	_, err = f.WriteString(token)
	if err != nil {
		return fmt.Errorf("SaveTokenToFile: %w", err)
	}

	return nil
}

func WithToken(f func() error) error {
	if err := f(); err != nil {
		if rmErr := removeToken(); rmErr != nil {
			return fmt.Errorf("WithToken: %w\nWithToken: %w", err, rmErr)
		}
		return fmt.Errorf("WithToken: %w", err)
	}

	if err := removeToken(); err != nil {
		return fmt.Errorf("WithToken: %w", err)
	}

	return nil
}

func removeToken() error {
	if err := os.Remove(tokenFilePath); err != nil {
		return fmt.Errorf("removeToken: %w", err)
	}
	return nil
}
```

</details>

## GCP での設定

こちらも基本的には[公式のドキュメント](https://cloud.google.com/iam/docs/workload-identity-federation-with-other-providers?hl=ja)に従います。

### コンソールでの設定

#### API を有効化する

まずは必要な API を有効化します。

必要な API については公式のドキュメントを参照してください。

#### Workload Identity プールを作成する

次に IAM と管理 > Workload Identity 連携 から プールを作成 を押します。

画面の指示に従って Workload Identity プールを作成します。

プロバイダの設定では、プロバイダとして OpenID Connect (OIDC) を選択し、
発行元は Auth0 の認証 URL を指定します。

オーディエンスは許可するオーディエンスとして、 Auth0 の Client ID を指定します。

<postimage src="Create Workload Identity pool" alt="Create Workload Identity pool" />

属性のマッピングでは、`google.subject = assertion.sub` と指定します。

#### サービスアカウントを作成する

IAM と管理 > サービス アカウント から CREATE SERVICE ACCOUNT を押します。

ロールの選択では、Workload Identity ユーザーと、使用したいリソースへのアクセス権をもつロール (Cloud Datastore ユーザー など) を指定します。

<postimage src="Service account roles" alt="Service account roles" />

### Workload にサービスアカウントの権限を許可する

IAM と管理 > Workload Identity 連携 からさきほど作成したプールを選択し、アクセスを許可 を押します。

さきほど作成したサービスアカウントを指定し、保存を押します。

ダイアログが表示されますので、 OIDC ID tokenのパス には ID トークンを保存するファイルのパス (`./tmp/app-token`) を指定し、
フォーマット タイプ にはテキストを指定します。

<postimage src="Download configuration file" alt="Download configuration file" />

構成をダウンロード を押すと JSON ファイルがダウンロードされるので、
これをプロジェクトに置きます。

このファイルにはサービスアカウントキーと違って機密情報が含まれていません！<img className="emoji" draggable="false" alt="🔒" src="https://twemoji.maxcdn.com/v/13.1.0/72x72/1f512.png"/>

コンソール上での設定は以上となります。

### 実装

環境変数 `GOOGLE_APPLICATION_CREDENTIALS` に、次のように構成情報ファイルへのパスを指定しておくと、
Cloud クライアントライブラリは特にコード内で指定しなくても[デフォルト認証情報](https://cloud.google.com/docs/authentication/application-default-credentials)としてそのファイルを見てくれます。

```
GOOGLE_APPLICATION_CREDENTIALS=clientLibraryConfig-app.json
```

以下には例として、 Cloud Datastore にアクセスする処理を書いています。

```go name=app/cmd/main.go
package main

import (
	"context"
	"fmt"
	"log"
	"app/internal/auth/authenticator"
	"app/internal/auth/server"
	"app/internal/auth/token"
	"app/internal/constants"

	"cloud.google.com/go/datastore"
)

func main() {
	if err := authenticate(); err != nil {
		log.Fatal(err)
	}

	if err := token.WithToken(run); err != nil {
		log.Fatal(err)
	}
}

func authenticate() error {
	auth, err := authenticator.New()
	if err != nil {
		return fmt.Errorf("authenticate: %w", err)
	}

	server.RunServer(auth)

	return nil
}

func run() error {
	ctx := context.Background()
	client, err := datastore.NewClient(ctx, constants.PROJECT_ID)
	if err != nil {
		return nil, fmt.Errorf("run: %w", err)
	}
	defer client.Close()

	// Some actions for Datastore

	return nil
}
```

以上で、 Auth0 を用いた Workload Identity 連携ができました！

これで、サービスアカウントキーを管理するコストを省きつつ、アプリケーションの安全性を高めることができます。

この記事が参考になったらうれしいです。

ではまた <img className="emoji" draggable="false" alt="👋" src="https://twemoji.maxcdn.com/v/13.1.0/72x72/1f44b.png"/>

Cloud Datastore などの Google Cloud リソースにアクセスする際にサービスアカウントを作成することがあります。
サービスアカウントはリソースにアクセスする際に様々な認証方法を使用することができます。
そのうちのひとつがサービスアカウントキーで、これはユーザーがユーザー名とパスワードを使って認証するのと同じような方法です。
…

Go

Auth0 で Workload Identity 連携