K8s: fix standalone command and add hack scripts (grafana#79052)

Co-authored-by: Charandas Batra <[email protected]>

Author: ryantxu

.github/CODEOWNERS

@@ -65,6 +65,7 @@
 /.golangci.toml @grafana/backend-platform
 /build.go @grafana/backend-platform
 /scripts/modowners/ @grafana/backend-platform
+/hack/ @grafana/grafana-app-platform-squad
 
 /pkg/api/ @grafana/backend-platform
 /pkg/apis/ @grafana/grafana-app-platform-squad

.gitignore

@@ -80,6 +80,9 @@ public/css/*.min.css
 apiserver.local.config/
 default.etcd/
 
+# kubeconfig path used by example apiserver
+example-apiserver/
+
 # devenv
 /devenv/docker-compose.yaml
 /devenv/docker-compose.override.yaml

.vscode/launch.json

@@ -11,6 +11,16 @@
       "cwd": "${workspaceFolder}",
       "args": ["server", "--homepath", "${workspaceFolder}", "--packaging", "dev"]
     },
+    {
+      "name": "Run API Server (k8s)",
+      "type": "go",
+      "request": "launch",
+      "mode": "auto",
+      "program": "${workspaceFolder}/pkg/cmd/grafana/",
+      "env": {},
+      "cwd": "${workspaceFolder}",
+      "args": ["apiserver", "example.grafana.app"]
+    },
     {
       "name": "Attach to Chrome",
       "port": 9222,

docs/sources/setup-grafana/configure-grafana/feature-toggles/index.md

@@ -143,6 +143,7 @@ Experimental features might be changed or removed without prior notice.
 | `enableNativeHTTPHistogram`                 | Enables native HTTP Histograms                                                                                                                                                                                                                                                    |
 | `formatString`                              | Enable format string transformer                                                                                                                                                                                                                                                  |
 | `kubernetesPlaylists`                       | Use the kubernetes API in the frontend for playlists, and route /api/playlist requests to k8s                                                                                                                                                                                     |
+| `kubernetesSnapshots`                       | Use the kubernetes API in the frontend to support playlists                                                                                                                                                                                                                       |
 | `recoveryThreshold`                         | Enables feature recovery threshold (aka hysteresis) for threshold server-side expression                                                                                                                                                                                          |
 | `lokiStructuredMetadata`                    | Enables the loki data source to request structured metadata from the Loki server                                                                                                                                                                                                  |
 | `teamHttpHeaders`                           | Enables datasources to apply team headers to the client requests                                                                                                                                                                                                                  |

hack/README.md

@@ -0,0 +1,25 @@
+# Kubernetes HACK Alert
+
+This is a hack folder for kubernetes codegen scripts. Oddly, a /hack/ folder seems to be standard kubernetes development practice ¯\_(ツ)\_/¯
+
+The workflow is a WIP, however we are trying to leverage as many off-the-shelf patterns as possible.
+
+For these scripts to work, your local GOROOT/src/grafana/grafana must point to this git checkout. For my setup this is:
+
+```
+❯ pwd
+/Users/ryan/go/src/github.com/grafana
+❯ ls -l
+total 0
+lrwxr-xr-x  1 ryan  staff  37 Oct  5 09:34 grafana -> /Users/ryan/workspace/grafana/grafana
+```
+
+The current workflow (sorry!) is to:
+
+1. update the script to point to the group+version you want
+2. run the `update-codegen.sh` script. This will produce a bunch of new files
+3. move `pkg/generated/openapi/zz_generated.openapi.go` to `pkg/apis/{group/version}/zz_generated.openapi.go`.
+4. edit the package name so it is {version} and remove the boilerplate k8s kinds
+5. `rm -rf pkg/generated` -- we are not yet using most of the generated client stuff
+
+Once we are more comfortable with the outputs and process, we will build these steps into a more standard codegen pattern, but until then... happy hacking!

hack/boilerplate.go.txt

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+

hack/update-codegen.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+
+# Copyright 2017 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+SCRIPT_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
+CODEGEN_PKG=${CODEGEN_PKG:-$(cd "${SCRIPT_ROOT}"; ls -d -1 ./vendor/k8s.io/code-generator 2>/dev/null || echo $GOPATH/pkg/mod/k8s.io/code-generator@v0.27.1)}
+
+OUTDIR="${HOME}/go/src"
+
+echo $OUTDIR
+
+CLIENTSET_NAME_VERSIONED=clientset \
+CLIENTSET_PKG_NAME=clientset \
+"${CODEGEN_PKG}/generate-groups.sh" "all" \
+  github.com/grafana/grafana/pkg/generated \
+  github.com/grafana/grafana/pkg/apis \
+  "snapshots:v0alpha1" \
+  --output-base "${OUTDIR}" \
+  --go-header-file "${SCRIPT_ROOT}/hack/boilerplate.go.txt"
+
+CLIENTSET_NAME_VERSIONED=clientset \
+CLIENTSET_PKG_NAME=clientset \
+"${CODEGEN_PKG}/generate-internal-groups.sh" "deepcopy,defaulter,conversion,openapi"  \
+  github.com/grafana/grafana/pkg/generated \
+  github.com/grafana/grafana/pkg/apis \
+  github.com/grafana/grafana/pkg/apis \
+  "snapshots:v0alpha1" \
+  --output-base "${OUTDIR}" \
+  --go-header-file "${SCRIPT_ROOT}/hack/boilerplate.go.txt"

packages/grafana-data/src/types/featureToggles.gen.ts

@@ -135,6 +135,7 @@ export interface FeatureToggles {
   formatString?: boolean;
   transformationsVariableSupport?: boolean;
   kubernetesPlaylists?: boolean;
+  kubernetesSnapshots?: boolean;
   cloudWatchBatchQueries?: boolean;
   recoveryThreshold?: boolean;
   lokiStructuredMetadata?: boolean;

pkg/cmd/grafana/apiserver/README.md

@@ -4,22 +4,45 @@ The example-apiserver closely resembles the
 [sample-apiserver](https://github.com/kubernetes/sample-apiserver/tree/master) project in code and thus
 allows the same
 [CLI flags](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/) as kube-apiserver.
-It is currently used for testing our deployment pipelines for aggregated servers.
+It is currently used for testing our deployment pipelines for aggregated servers. You can optionally omit the
+aggregation path altogether and just run this example apiserver as a standalone process.
 
-## Prerequisites:
+## Standalone Mode
+
+### Usage
+
+```shell
+go run ./pkg/cmd/grafana apiserver example.grafana.app \
+  --secure-port 8443
+```
+
+### Verify that all works
+
+```shell
+export KUBECONFIG=./example-apiserver/kubeconfig
+
+kubectl api-resources
+NAME      SHORTNAMES   APIVERSION                     NAMESPACED   KIND
+dummy                  example.grafana.app/v0alpha1   true         DummyResource
+runtime                example.grafana.app/v0alpha1   false        RuntimeInfo
+```
+
+## Aggregated Mode
+
+### Prerequisites:
 1. kind: you will need kind (or another local K8s setup) if you want to test aggregation.
   ```
   go install sigs.k8s.io/[email protected] && kind create cluster
   ```
 
-## Usage
+### Usage
 
 You can start the example-apiserver with an invocation as shown below. The Authn / Authz flags are set up so that the kind cluster
 can be used as a root server for this example-apiserver (in aggregated mode). Here, it's assumed that you have a local
 kind cluster and that you can provide its kubeconfig in the parameters to the example-apiserver.
 
 ```shell
-go run ./pkg/cmd/grafana apiserver example.grafana.app\
+go run ./pkg/cmd/grafana apiserver example.grafana.app \
   --authentication-kubeconfig ~/.kube/config \
   --authorization-kubeconfig ~/.kube/config \
   --kubeconfig ~/.kube/config \
@@ -35,7 +58,7 @@ kubectl deploy -k ./deploy/darwin # or /linux
 ```
 
 
-## Verify that all works
+### Verify that all works
 
 With kubectl configured against `kind-kind` context, you can run the following:
 

pkg/cmd/grafana/apiserver/cmd.go

@@ -1,7 +1,6 @@
 package apiserver
 
 import (
-	"fmt"
 	"os"
 
 	"github.com/spf13/cobra"
@@ -10,32 +9,22 @@ import (
 	"k8s.io/component-base/cli"
 )
 
-func newCommandStartExampleAPIServer(o *ExampleServerOptions, stopCh <-chan struct{}) *cobra.Command {
-	// While this exists as an experimental feature, we require adding the scarry looking command line
-	devAcknowledgementFlag := "grafana-enable-experimental-apiserver"
+func newCommandStartExampleAPIServer(o *APIServerOptions, stopCh <-chan struct{}) *cobra.Command {
 	devAcknowledgementNotice := "The apiserver command is in heavy development.  The entire setup is subject to change without notice"
 
 	cmd := &cobra.Command{
 		Use:   "apiserver [api group(s)]",
 		Short: "Run the grafana apiserver",
 		Long: "Run a standalone kubernetes based apiserver that can be aggregated by a root apiserver. " +
 			devAcknowledgementNotice,
-		Example: fmt.Sprintf("grafana apiserver example.grafana.app --%s", devAcknowledgementFlag),
-		PersistentPreRun: func(cmd *cobra.Command, args []string) {
-			ok, err := cmd.Flags().GetBool(devAcknowledgementFlag)
-			if !ok || err != nil {
-				fmt.Printf("requires running with the flag: --%s\n\n%s\n\n",
-					devAcknowledgementFlag, devAcknowledgementNotice)
-				os.Exit(1)
-			}
-		},
+		Example: "grafana apiserver example.grafana.app",
 		RunE: func(c *cobra.Command, args []string) error {
 			// Load each group from the args
 			if err := o.LoadAPIGroupBuilders(args[1:]); err != nil {
 				return err
 			}
 
-			// Finish the config (applies all defaults)
+			// Finish the config (a noop for now)
 			if err := o.Complete(); err != nil {
 				return err
 			}
@@ -45,16 +34,13 @@ func newCommandStartExampleAPIServer(o *ExampleServerOptions, stopCh <-chan stru
 				return err
 			}
 
-			if err := o.RunExampleServer(config, stopCh); err != nil {
+			if err := o.RunAPIServer(config, stopCh); err != nil {
 				return err
 			}
 			return nil
 		},
 	}
 
-	// Register grafana flags
-	cmd.PersistentFlags().Bool(devAcknowledgementFlag, false, devAcknowledgementNotice)
-
 	// Register standard k8s flags with the command line
 	o.RecommendedOptions = options.NewRecommendedOptions(
 		defaultEtcdPathPrefix,
@@ -68,7 +54,7 @@ func newCommandStartExampleAPIServer(o *ExampleServerOptions, stopCh <-chan stru
 func RunCLI() int {
 	stopCh := genericapiserver.SetupSignalHandler()
 
-	options := newExampleServerOptions(os.Stdout, os.Stderr)
+	options := newAPIServerOptions(os.Stdout, os.Stderr)
 	cmd := newCommandStartExampleAPIServer(options, stopCh)
 
 	return cli.Run(cmd)