Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
// Package federatedcredentials manages workload identity federation trust rules.
package federatedcredentials
import (
"cmp"
"fmt"
"net/http"
"strconv"
"time"
"github.com/getarcaneapp/arcane/types/v2/federated"
"github.com/spf13/cobra"
"go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
"github.com/getarcaneapp/arcane/cli/v2/internal/output"
"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)
// Command is the parent command for federated credential operations.
func Command() *cobra.Command {
command := &cobra.Command{
Use: "federated",
Aliases: []string{"fedcreds", "federated-credentials"},
Short: "Manage workload identity federation trust rules",
}
command.AddCommand(newListCmd())
command.AddCommand(newGetCmd())
command.AddCommand(newCreateCmd())
command.AddCommand(newUpdateCmd())
command.AddCommand(newDeleteCmd())
return command
}
func newListCmd() *cobra.Command {
var opts struct {
limit int
start int
all bool
}
command := &cobra.Command{
Use: "list",
Aliases: []string{"ls"},
Short: "List federated credentials",
SilenceUsage: true,
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.RunList(cmd, c, cmdutil.ListSpec[federated.FederatedCredential]{
Resource: "federated credentials",
Endpoint: types.FederatedCredentials(),
Params: cmdutil.ListParams{Resource: "federated-credentials", Limit: opts.limit, FallbackDefault: 20, Start: opts.start, All: opts.all},
Headers: []string{"ID", "NAME", "ISSUER", "SUBJECT", "ROLE", "ENABLED"},
Row: func(cred federated.FederatedCredential) []string {
return []string{cred.ID, cred.Name, cred.IssuerURL, cred.SubjectMatch, cmp.Or(cred.RoleName, cred.RoleID), strconv.FormatBool(cred.Enabled)}
},
})
},
}
command.Flags().IntVarP(&opts.limit, "limit", "n", 20, "Number of federated credentials to show")
command.Flags().IntVar(&opts.start, "start", 0, cmdutil.StartFlagUsage)
command.Flags().BoolVarP(&opts.all, "all", "a", false, cmdutil.AllFlagUsage)
return command
}
func newGetCmd() *cobra.Command {
return &cobra.Command{
Use: "get <credential-id>",
Short: "Get federated credential details",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.Run(cmd, c, cmdutil.Spec[federated.FederatedCredential]{
Method: http.MethodGet,
Path: types.FederatedCredential(args[0]),
FailureMessage: "failed to get federated credential",
Render: func(data federated.FederatedCredential) error {
printCredential(data)
return nil
},
})
},
}
}
func newCreateCmd() *cobra.Command {
var opts struct {
name string
description string
disabled bool
issuerURL string
audiences []string
subjectClaim string
subjectMatch string
matchType string
roleID string
environment string
tokenTTL int
expiresAt string
}
command := &cobra.Command{
Use: "create",
Short: "Create a federated credential",
Example: ` arcane admin federated create --name github-actions --issuer-url https://token.actions.githubusercontent.com \
--audience arcane --subject-match "repo:myorg/*" --match-type glob --role role_deployer`,
SilenceUsage: true,
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
var expiresAt *time.Time
if opts.expiresAt != "" {
parsed, parseErr := time.Parse(time.RFC3339, opts.expiresAt)
if parseErr != nil {
return fmt.Errorf("invalid --expires-at format (use RFC3339): %w", parseErr)
}
expiresAt = &parsed
}
return cmdutil.Run(cmd, c, cmdutil.Spec[federated.FederatedCredential]{
Method: http.MethodPost,
Path: types.FederatedCredentials(),
FailureMessage: "failed to create federated credential",
Body: federated.CreateFederatedCredential{
Name: opts.name,
// TODO(v3): drop the deprecated flag handling.
Enabled: !opts.disabled,
IssuerURL: opts.issuerURL,
Audiences: opts.audiences,
SubjectClaim: opts.subjectClaim,
SubjectMatch: opts.subjectMatch,
MatchType: opts.matchType,
RoleID: opts.roleID,
Description: kit.Ternary(cmd.Flags().Changed("description"), &opts.description, nil),
EnvironmentID: kit.Ternary(cmd.Flags().Changed("environment") && opts.environment != "", new(opts.environment), nil),
TokenTTLSeconds: kit.Ternary(cmd.Flags().Changed("token-ttl"), opts.tokenTTL, 0),
ExpiresAt: expiresAt,
},
Render: func(data federated.FederatedCredential) error {
output.Success("Federated credential created")
printCredential(data)
return nil
},
})
},
}
command.Flags().StringVar(&opts.name, "name", "", "Display name (required)")
command.Flags().StringVar(&opts.description, "description", "", "Description")
command.Flags().BoolVar(&opts.disabled, "disabled", false, "Create the trust rule in disabled state")
command.Flags().StringVar(&opts.issuerURL, "issuer-url", "", "Trusted external OIDC issuer URL (required)")
command.Flags().StringArrayVar(&opts.audiences, "audience", nil, "Allowed external token audience (repeatable, required)")
command.Flags().StringVar(&opts.subjectClaim, "subject-claim", "", "Claim path to match against (defaults to sub)")
command.Flags().StringVar(&opts.subjectMatch, "subject-match", "", "Exact subject or anchored glob pattern (required)")
cmdutil.EnumVarP(command, command.Flags(), &opts.matchType, "match-type", "", "", "Subject match strategy",
federated.MatchTypeExact, federated.MatchTypeGlob)
command.Flags().StringVar(&opts.roleID, "role", "", "Role ID to map exchanged tokens to (required)")
command.Flags().StringVar(&opts.environment, "environment", "", "Scope the role assignment to one environment (omit for global)")
command.Flags().IntVar(&opts.tokenTTL, "token-ttl", 0, "Issued token lifetime in seconds (60-3600)")
command.Flags().StringVar(&opts.expiresAt, "expires-at", "", "Credential expiration (RFC3339 format)")
_ = command.MarkFlagRequired("name")
_ = command.MarkFlagRequired("issuer-url")
_ = command.MarkFlagRequired("audience")
_ = command.MarkFlagRequired("subject-match")
_ = command.MarkFlagRequired("role")
return command
}
func newUpdateCmd() *cobra.Command {
var opts struct {
name string
description string
enabled bool
disabled bool
issuerURL string
audiences []string
subjectClaim string
subjectMatch string
matchType string
roleID string
tokenTTL int
environment string
expiresAt string
}
command := &cobra.Command{
Use: "update <credential-id>",
Short: "Update a federated credential",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
PreRunE: func(cmd *cobra.Command, _ []string) error {
// TODO(v3): drop the deprecated flag handling.
return cmdutil.ExclusiveFlags(cmd, "enabled", "disabled")
},
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
var environmentID *string
if cmd.Flags().Changed("environment") {
environmentID = kit.Ternary(opts.environment != "", &opts.environment, nil)
}
var expiresAt *time.Time
if cmd.Flags().Changed("expires-at") && opts.expiresAt != "" {
parsed, parseErr := time.Parse(time.RFC3339, opts.expiresAt)
if parseErr != nil {
return fmt.Errorf("invalid --expires-at format (use RFC3339): %w", parseErr)
}
expiresAt = &parsed
}
return cmdutil.Run(cmd, c, cmdutil.Spec[federated.FederatedCredential]{
Method: http.MethodPut,
Path: types.FederatedCredential(args[0]),
FailureMessage: "failed to update federated credential",
Body: federated.UpdateFederatedCredential{
Name: kit.Ternary(cmd.Flags().Changed("name"), &opts.name, nil),
Description: kit.Ternary(cmd.Flags().Changed("description"), &opts.description, nil),
// TODO(v3): drop the deprecated flag handling.
Enabled: kit.Ternary(cmd.Flags().Changed("enabled") || cmd.Flags().Changed("disabled"), new(opts.enabled && !opts.disabled), nil),
IssuerURL: kit.Ternary(cmd.Flags().Changed("issuer-url"), &opts.issuerURL, nil),
Audiences: kit.Ternary(cmd.Flags().Changed("audience"), opts.audiences, nil),
SubjectClaim: kit.Ternary(cmd.Flags().Changed("subject-claim"), &opts.subjectClaim, nil),
SubjectMatch: kit.Ternary(cmd.Flags().Changed("subject-match"), &opts.subjectMatch, nil),
MatchType: kit.Ternary(cmd.Flags().Changed("match-type"), &opts.matchType, nil),
RoleID: kit.Ternary(cmd.Flags().Changed("role"), &opts.roleID, nil),
EnvironmentID: environmentID,
TokenTTLSeconds: kit.Ternary(cmd.Flags().Changed("token-ttl"), &opts.tokenTTL, nil),
ExpiresAt: expiresAt,
},
Render: func(data federated.FederatedCredential) error {
output.Success("Federated credential updated")
printCredential(data)
return nil
},
})
},
}
command.Flags().StringVar(&opts.name, "name", "", "New display name")
command.Flags().StringVar(&opts.description, "description", "", "New description")
command.Flags().BoolVar(&opts.enabled, "enabled", false, "Enable the trust rule")
command.Flags().BoolVar(&opts.disabled, "disabled", false, "Disable the trust rule")
// TODO(v3): remove the deprecated --disabled flag.
_ = command.Flags().MarkDeprecated("disabled", "use --enabled=false")
command.Flags().StringVar(&opts.issuerURL, "issuer-url", "", "New issuer URL")
command.Flags().StringArrayVar(&opts.audiences, "audience", nil, "Replace allowed audiences (repeatable)")
command.Flags().StringVar(&opts.subjectClaim, "subject-claim", "", "New claim path to match against")
command.Flags().StringVar(&opts.subjectMatch, "subject-match", "", "New subject match pattern")
cmdutil.EnumVarP(command, command.Flags(), &opts.matchType, "match-type", "", "", "New match strategy",
federated.MatchTypeExact, federated.MatchTypeGlob)
command.Flags().StringVar(&opts.roleID, "role", "", "New role ID")
command.Flags().StringVar(&opts.environment, "environment", "", "New environment scope")
command.Flags().IntVar(&opts.tokenTTL, "token-ttl", 0, "New issued token lifetime in seconds (60-3600)")
command.Flags().StringVar(&opts.expiresAt, "expires-at", "", "New credential expiration (RFC3339 format)")
return command
}
func newDeleteCmd() *cobra.Command {
var opts struct {
force bool
}
command := &cobra.Command{
Use: "delete <credential-id>",
Aliases: []string{"rm", "remove"},
Short: "Delete a federated credential",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.RunDelete(cmd, c, cmdutil.DeleteSpec{
Force: opts.force,
Prompt: fmt.Sprintf("Delete federated credential %s and its service user?", args[0]),
Path: types.FederatedCredential(args[0]),
FailureMessage: "failed to delete federated credential",
SuccessMessage: "Federated credential deleted",
})
},
}
command.Flags().BoolVarP(&opts.force, "force", "f", false, "Force deletion without confirmation")
return command
}
func printCredential(cred federated.FederatedCredential) {
output.KeyValue("ID", cred.ID)
output.KeyValue("Name", cred.Name)
if cred.Description != nil && *cred.Description != "" {
output.KeyValue("Description", *cred.Description)
}
output.KeyValue("Enabled", strconv.FormatBool(cred.Enabled))
output.KeyValue("Issuer URL", cred.IssuerURL)
output.KeyValue("Audiences", cred.Audiences)
output.KeyValue("Subject claim", cred.SubjectClaim)
output.KeyValue("Subject match", cred.SubjectMatch)
output.KeyValue("Match type", cred.MatchType)
output.KeyValue("Role", cmp.Or(cred.RoleName, cred.RoleID))
scope := "global"
if cred.EnvironmentID != nil {
scope = *cred.EnvironmentID
if cred.EnvironmentName != "" {
scope = fmt.Sprintf("%s (%s)", cred.EnvironmentName, *cred.EnvironmentID)
}
}
output.KeyValue("Scope", scope)
output.KeyValue("Token TTL (s)", cred.TokenTTLSeconds)
if cred.ServiceUsername != "" {
output.KeyValue("Service user", cred.ServiceUsername)
}
if cred.LastUsedAt != nil {
output.KeyValue("Last used", cred.LastUsedAt.Format("2006-01-02 15:04"))
}
if cred.ExpiresAt != nil {
output.KeyValue("Expires", cred.ExpiresAt.Format("2006-01-02 15:04"))
}
}