clivern / beetle Goto Github PK

update readme & add k8s yml files

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• Update prom/prometheus Docker tag to v2.53.1
• Update golang Docker tag to v1.22.5
• Update kubernetes packages to v0.30.3 (k8s.io/api, k8s.io/apimachinery, k8s.io/client-go)
• Click on this checkbox to rebase all open PRs at once

Ignored or Blocked

These are blocked by an existing closed PR and will not be recreated unless you click a checkbox below.

• Update module github.com/briandowns/spinner to v1.23.1
• Update module github.com/prometheus/client_golang to v1.19.1
• Update module github.com/spf13/viper to v1.19.0
• Update actions/setup-go action to v5
• Update goreleaser/goreleaser-action action to v6
• Update grafana/grafana Docker tag to v11
• Update module github.com/logrusorgru/aurora/v3 to v4

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

go to https://editor.swagger.io/, import this file https://raw.githubusercontent.com/Clivern/Beetle/master/swagger.yaml & then open a PR with ur changes

This project looks very cool, and is speaking my language (I think) when it comes to solving a very real need that I have experienced when running applications on k8s. But, back to the "I think" from above... what exactly is it? Is it meant to compete with something like Helm? Does it use/interoperate with Helm? Is it a wrapper around Helm? Is it a wrapper around the terraform k8s plugin? Is it a service harness/chassis/runtime and a central server and some other glue for introspection on running/apps deployments (the example config file makes me feel like it might be something like that... but I honestly can't tell from the README...)

Anyway, saw this on the Changelog newsletter, and I'm intrigued... but I still am not really sure what it is.

So I guess my feature request would be a section in the README that explains that.

We can mount clusters configs to beetle pod but go-client supports also InClusterConfig.

https://github.com/kubernetes/client-go/blob/be97aaa976ad58026e66cd9af5aaf1b006081f09/rest/config.go#L459-L488

https://github.com/kubernetes/client-go/tree/master/examples/in-cluster-client-configuration
https://kubernetes.io/docs/reference/access-authn-authz/authentication/#service-account-tokens

GET /api/v1/cluster/<clusterName>/namespace/<namespaceName>/application

Cluster Configs

If only version (eg. 1.0.0 or 1.1.0) will be provided to deployment & rollback endpoints

    applications:
      -
        name: Toad App
        id: toad
        image: clivern/toad:release-[.Release]

If only version or version with suffix (eg. 1.0.0 or release-1.1.0 or version-1.0.0) will be provided to deployment & rollback endpoints

    applications:
      -
        name: Toad App
        id: toad
        image: clivern/toad:[.Release]

If the whole image will be provided (eg. clivern/toad:1.0.0 or clivern/toad:release-1.1.0 or clivern/toad:version-1.0.0) will be provided to deployment & rollback endpoints

    applications:
      -
        name: Toad App
        id: toad
        image: [.Release]

There is an error with this repository's Renovate configuration that needs to be fixed. As a precaution, Renovate will stop PRs until it is resolved.

Error type: undefined. Note: this is a nested preset so please contact the preset author if you are unable to fix it yourself.

beetle to revert back in case deployment failed (error, not enough resources, unhealthy pods ....etc)

will be part of beetle & split later

showing beetle, beetle workers, database, kubernetes clusters, namespaces, beetle reading from configMaps ...etc

It could be a cmd video of how to run beetle

should be pretty similar to #29

Figure out how to do that. Also a way to get all releases available for deployment or text input/api parameter

Deployment strategies that can be supported.

recreate: terminate the old version and release the new one.
ramped: release a new version on a rolling update fashion, one after the other.
blue/green: release a new version alongside the old version then switch traffic.
canary: release a new version to a subset of users, then proceed to a full rollout.

Client -->
https://github.com/kubernetes/client-go/blob/master/kubernetes/typed/core/v1/core_client.go

ref.
https://semaphoreci.com/blog/kubernetes-deployment
https://www.weave.works/technologies/manually-updating-kubernetes-workloads/

$ kubectl patch deployment patch-demo --patch '{
	"spec": {
		"template": {
			"spec": {
				"containers": [
					{
						"name": "nginx",
						"image": "nginx:1.7.9"
					}
				]
			}
		}
	}
}'

https://github.com/kubernetes/client-go/blob/5194bac869679e2d68716e9eeddf23d3c13661e1/kubernetes/typed/apps/v1beta1/deployment.go#L183-L194

	payload := []model.PatchStringValue{
		model.PatchStringValue{
			Op:    "replace",
			Path:  "/spec/template/spec/containers/0/image",
			Value: "clivern/toad:release-0.2.3",
		},
	}

	data, _ := util.ConvertToJSON(payload)

	fmt.Println(cluster.PatchDeployment(
		context.Background(),
		ns,
		"toad-deployment",
		data,
	))

beetle should have http driver to read application version by app slug

GET -H 'X-AUTH-TOKEN: ...' $EXTERNAL_SERVICE_URL/<app_slug>

• Setup cluster and deploy a test application.
• Beetle In cluster deployment.
• Beetle outside cluster deployment.
• Beetle local environment deployment.
• How to Call beetle api server to deploy our application.
• Future features.

Change clientset to be a parameter/configurable so i can use https://github.com/kubernetes/client-go/blob/master/kubernetes/fake/clientset_generated.go#L114 for unit/func testing.

prototype

clientset := fake.NewSimpleClientset(&v1.Pod{
    ObjectMeta: metav1.ObjectMeta{
        Name:        "toad",
        Namespace:   "default",
        Annotations: map[string]string{},
    },
}, &v1.Pod{
    ObjectMeta: metav1.ObjectMeta{
        Name:        "clivern",
        Namespace:   "default",
        Annotations: map[string]string{},
    },
})

it could be separate processes talking through redis (for now) or rabbitmq.
OR separate go routines talking via redis or go channel.

ability to use beetle binary as command line tool to interact with running beetle instance. fetch data, deploy apps ... etc

or just terraform operator 🤔

• HTTP Webhooks for push notification.

Global Configs -> beetle yaml config file.
Other Configs that change per cluster & namespace -> namespaced configMaps

Something like that to load cluster.namespace configs?

"github.com/clivern/beetle/internal/app/model"
    
var data = []byte(`
version: 0.1.0
`)

// ideally from here 
item, _ := cluster.GetConfigMap(context.Background(), "namespace-here", "k8s-cluster-configmap-name")
item.Data

nc := model.NamespaceConfigs{}
nc.LoadFromYAML([]byte(item.Data))

narrowed down to

cluster.GetConfig(context.Background(), "~namespace-name~")