Go

In this document you can find code examples for a self-hosted Ory Kratos Go SDK.

info

Missing an example? Please create a feature request and it will be added here.

You can find more examples of SDK usage in the auto-generated documentation kratos-client.

Installation

If you are starting from scratch, first set up a new Go project

mkdir myproject
cd myproject
go mod init myproject

Install the Ory Kratos Go SDK

go get  github.com/ory/kratos-go@<version-you-want>

Configuration

The following code example shows how to set up and configure Ory Kratos using the Go SDK:

package main

import (
    "context"

    client "github.com/ory/kratos-go"
)

func main() {
    configuration := client.NewConfiguration()
    configuration.Servers = []client.ServerConfiguration{
        {
            URL: "http://127.0.0.1:4434", // Kratos Admin API
        },
    }
    apiClient := client.NewAPIClient(configuration)
    // resp, r, err := apiClient.FrontendApi.ToSession(context.Background()).Cookie("ory_Kratos_session").Execute()
}

Use Frontend API

The following code examples show how to use the FrontendApi.

toSession

In this example you make a toSession call to check if the session is active.

Open the the local hosted UI in your browser
Sign up and create an account and log in
Copy the ory_kratos_session cookie from the Application tab in your browser developer tools
Add the cookie value in cookie
Run the example and send the request with go run main.go

The response should look like this.

Traits  map[email:youremail@example.com]

package main

import (
    "context"
    "fmt"
    "os"

    client "github.com/ory/client-go"
)

func main() {
    configuration := client.NewConfiguration()
    configuration.Servers = []client.ServerConfiguration{
        {
            URL: "http://127.0.0.1:4433", // Kratos Public API
        },
    }
    apiClient := client.NewAPIClient(configuration)
    cookie := "ory_kratos_session=MTY0ODgyMTExN3xEdi1CQkFFQ180SUFBUkFCRUFBQVJfLUNBQUVHYzNSeWFXNW5EQThBRFhObGMzTnBiMjVmZEc5clpXNEdjM1J5YVc1bkRDSUFJRkZDVFVKbFNIcEJOalZyY0Vad1JEZ3dNMng1V0RsWlpEQlFXa3RoUjNJenzKCLhzCkox1OmvNJlKcqtWuNkSnPLrUgM6Ew2EMYksfg=="
    resp, r, err := apiClient.FrontendApi.ToSession(context.Background()).Cookie(cookie).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `FrontendApi.ToSession``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ToSession`: Session
    fmt.Fprintf(os.Stdout, "Traits  %v\n", resp.Identity.Traits)
}

Use Identity Management API

The following code examples show how to use the IdentityAPI requests need to be authorized.

CreateIdentity and DeleteIdentity

package main

import (
    "context"
    "fmt"
    "os"

    ory "github.com/ory/kratos-go"
)

func main() {
    configuration := ory.NewConfiguration()
    configuration.Servers = []ory.ServerConfiguration{
        {
            URL: "http://127.0.0.1:4434", // Kratos Admin API
        },
    }
    apiory := ory.NewAPIClient(configuration)
    CreateIdentityBody := *ory.NewCreateIdentityBody(
        "default",
        map[string]interface{}{
            "email": "foo@example.com",
            "name": map[string]string{
                "first": "foo",
                "last":  "bar",
            },
        },
    ) // CreateIdentityBody |  (optional)

    createdIdentity, r, err := apiClient.FrontendApi.CreateIdentity(context.Background()).CreateIdentityBody(CreateIdentityBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `FrontendApi.CreateIdentity``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateIdentity`: Identity
    fmt.Fprintf(os.Stdout, "Created identity with ID: %v\n", createdIdentity.Id)
    getIdentity, r, err := apiClient.FrontendApi.GetIdentity(context.Background(), createdIdentity.Id).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `FrontendApi.GetIdentity``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    fmt.Fprintf(os.Stdout, "Email for identity with id %v. Traits %v\n", createdIdentity.Id, getIdentity.Traits)

    r, err = apiClient.FrontendApi.DeleteIdentity(context.Background(), getIdentity.Id).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `FrontendApi.DeleteIdentity``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    fmt.Println("Successfully Removed identity")

}

Gin middleware

The following code example shows how to use the Kratos Go SDK with the Gin Web Framework. Follow the instructions in the README to install Gin.

Run the Gin middleware with go run main.go
Open the the local hosted UI in your browser
Sign up and create an account and log in
Copy the ory cookie from the Application tab in your browser developer tools
Add the cooie to the cUrl request below:

curl 'http://localhost:8080/ping' -b 'ory_kratos_session=<your-session-cookie-here>'
pong

package main

import (
    "context"
    "errors"
    "net/http"

    "github.com/gin-gonic/gin"
    ory "github.com/ory/kratos-go"
)

type kratosMiddleware struct {
    ory *ory.APIClient
}

func NewMiddleware() *kratosMiddleware {
    configuration := ory.NewConfiguration()
    configuration.Servers = []ory.ServerConfiguration{
        {
            URL: "http://127.0.0.1:4434", // Kratos Admin API
        },
    }
    return &kratosMiddleware{
        ory: ory.NewAPIClient(configuration),
    }
}
func (k *kratosMiddleware) Session() gin.HandlerFunc {
    return func(c *gin.Context) {
        session, err := k.validateSession(c.Request)
        if err != nil {
            c.Redirect(http.StatusMovedPermanently, "http://127.0.0.1:4455/login")
            return
        }
        if !*session.Active {
            c.Redirect(http.StatusMovedPermanently, "http://your_endpoint")
            return
        }
        c.Next()
    }
}
func (k *kratosMiddleware) validateSession(r *http.Request) (*ory.Session, error) {
    cookie, err := r.Cookie("ory_kratos_session")
    if err != nil {
        return nil, err
    }
    if cookie == nil {
        return nil, errors.New("no session found in cookie")
    }
    resp, _, err := k.ory.FrontendApi.ToSession(context.Background()).Cookie(cookie.String()).Execute()
    if err != nil {
        return nil, err
    }
    return resp, nil
}
func main() {

    r := gin.Default()
    k := NewMiddleware()

    r.Use(k.Session())
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

Echo middleware

The following code example shows how to use Kratos Go SDK with the Echo framework. Follow the instructions to install Echo.

Run the Echo middleware with go run main.go
Open the the local hosted UI in your browser
Sign up and create an account and log in
Copy the ory cookie from the Application tab in your browser developer tools
Add the cooie to the cUrl request below:

curl 'http://localhost:8080/ping' -b 'ory_kratos_session=<your-session-cookie-here>'
pong

package main

import (
    "context"
    "errors"
    "net/http"

    "github.com/labstack/echo/v4"

    ory "github.com/ory/kratos-go"
)

type kratosMiddleware struct {
    ory *ory.APIClient
}

func NewMiddleware() *kratosMiddleware {
    configuration := ory.NewConfiguration()
    configuration.Servers = []ory.ServerConfiguration{
        {
            URL: "http://127.0.0.1:4433", // Kratos Public API
        },
    }
    return &kratosMiddleware{
        ory: ory.NewAPIClient(configuration),
    }
}
func (k *kratosMiddleware) Session(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
        session, err := k.validateSession(c.Request())
        if err != nil {
            return c.Redirect(http.StatusMovedPermanently, "http://127.0.0.1:4455/login")
        }
        if !*session.Active {
            return c.Redirect(http.StatusMovedPermanently, "http://your_endpoint")
        }
        return next(c)
    }
}
func (k *kratosMiddleware) validateSession(r *http.Request) (*ory.Session, error) {
    cookie, err := r.Cookie("ory_kratos_session")
    if err != nil {
        return nil, err
    }
    if cookie == nil {
        return nil, errors.New("no session found in cookie")
    }
    resp, _, err := k.ory.FrontendApi.ToSession(context.Background()).Cookie(cookie.String()).Execute()
    if err != nil {
        return nil, err
    }
    return resp, nil
}
func main() {

    k := NewMiddleware()
    e := echo.New()
    e.Use(k.Session)
    e.GET("/hello", func(c echo.Context) error {
        return c.String(http.StatusOK, "Hello, World!")
    })
    e.Logger.Fatal(e.Start(":1323"))
}

Installation​

Configuration​

Use Frontend API​

toSession​

Use Identity Management API​

CreateIdentity and DeleteIdentity​

Gin middleware​

Echo middleware​