Use client.go to search for requestable resources

[programmerq]

This is a quick example for how to use client.go to use your active tsh profile, run a resource search, and output the results. It's not the most user-friendly, and was just something thrown together to illustrate using client.go to do the equivalent of tsh request search

Usage of teleport-search:
  -f string
    	Output format: json or yaml (default "json")
  -labels string
    	Labels to search for (json object of key=value pairs)
  -predicate-expression string
    	Predicate expression to use for search (raw string)
  -resource-kind string
    	Resource kind to search for (node|db|app|kube)
  -search-keywords string
    	Keywords to use for search (json object array of strings)

go run main.go --resource-kind=node --labels '{"env": "prod"}'

package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"github.com/gravitational/teleport/api/accessrequest"
	"github.com/gravitational/teleport/api/client"
	"github.com/gravitational/teleport/api/client/proto"
	"github.com/gravitational/teleport/api/types"
	"gopkg.in/yaml.v3"
	"log"
)

// FetchResources fetches resources based on provided filters.
func FetchResources(clt *client.Client, resourceKind string, labels map[string]string, predicateExpression string, searchKeywords []string) (types.ResourcesWithLabels, error) {
	ctx := context.Background()

	req := proto.ListResourcesRequest{
		Labels:              labels,
		PredicateExpression: predicateExpression,
		SearchKeywords:      searchKeywords,
		UseSearchAsRoles:    true,
	}

	return accessrequest.GetResourcesByKind(ctx, clt, req, resourceKind)
}

func main() {
	var (
		resourceKind        string
		labels              string
		predicateExpression string
		searchKeywords      string
		format              string
	)

	flag.StringVar(&resourceKind, "resource-kind", "", "Resource kind to search for")
	flag.StringVar(&labels, "labels", "", "Labels to search for")
	flag.StringVar(&predicateExpression, "predicate-expression", "", "Predicate expression to use for search")
	flag.StringVar(&searchKeywords, "search-keywords", "", "Keywords to use for search")
	flag.StringVar(&format, "f", "json", "Output format: json or yaml")
	flag.Parse()

	if resourceKind == "" {
		log.Fatalf("resource-kind is required")
	}

	ctx := context.Background()
	clt, err := client.New(ctx, client.Config{
		Credentials: []client.Credentials{
			client.LoadProfile("", ""),
		},
	})

	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	defer clt.Close()

	// parse labels string to split into key/value map
	labelsMap := make(map[string]string)
	if labels != "" {
		err := json.Unmarshal([]byte(labels), &labelsMap)
		if err != nil {
			log.Fatalf("Failed to parse labels: %v", err)
		}
	}

	// parse search keywords string to split into slice
	var searchKeywordsSlice []string
	if searchKeywords != "" {
		err := json.Unmarshal([]byte(searchKeywords), &searchKeywordsSlice)
		if err != nil {
			log.Fatalf("Failed to parse search keywords: %v", err)
		}
	}

	resources, err := FetchResources(clt, resourceKind, labelsMap, predicateExpression, searchKeywordsSlice)
	if err != nil {
		log.Fatalf("Failed to fetch resources: %v", err)
	}

	var output []byte

	switch format {
	case "json":
		output, err = json.MarshalIndent(resources, "", "  ")
		if err != nil {
			log.Fatalf("Failed to marshal to JSON: %v", err)
		}
	case "yaml":
		output, err = yaml.Marshal(resources)
		if err != nil {
			log.Fatalf("Failed to marshal to YAML: %v", err)
		}
	default:
		log.Fatalf("Invalid format: %s", format)
	}

	fmt.Println(string(output))
}