kubectl clone: Seamlessly Clone Kubernetes Resources Across Multiple Rancher Clusters and Projects by dpunia

Description

kubectl clone is a kubectl plugin that empowers users to clone Kubernetes resources across multiple clusters and projects managed by Rancher. It simplifies the process of duplicating resources from one cluster to another or within different namespaces and projects, with optional on-the-fly modifications. This tool enhances multi-cluster resource management, making it invaluable for environments where Rancher orchestrates numerous Kubernetes clusters.

Goals

1. Seamless Multi-Cluster Cloning
   • Clone Kubernetes resources across clusters/projects with one command.
   • Simplifies management, reduces operational effort.

Resources

1. Rancher & Kubernetes Docs

   • Rancher API, Cluster Management, Kubernetes client libraries.

2. Development Tools

   • Kubectl plugin docs, Go programming resources.

Building and Installing the Plugin

1. Set Environment Variables: Export the Rancher URL and API token:

• export RANCHER_URL="https://rancher.example.com"
• export RANCHER_TOKEN="token-xxxxx:xxxxxxxxxxxxxxxxxxxx"

1. Build the Plugin: Compile the Go program:

• go build -o kubectl-clone ./pkg/

1. Install the Plugin: Move the executable to a directory in your PATH:

• mv kubectl-clone /usr/local/bin/

Ensure the file is executable:

• chmod +x /usr/local/bin/kubectl-clone

1. Verify the Plugin Installation: Test the plugin by running:

• kubectl clone --help

You should see the usage information for the kubectl-clone plugin.

Usage Examples

1. Clone a Deployment from One Cluster to Another:

• kubectl clone --source-cluster c-abc123 --type deployment --name nginx-deployment --target-cluster c-def456 --new-name nginx-deployment-clone

1. Clone a Service into Another Namespace and Modify Labels:

---

Dartboard TUI by IValentin

Description

Our scalability and performance testing swiss-army knife tool Dartboard is a major WIP so why not add more scope creep? Dartboard is a cli tool which enables users to:

• Define a "Dart" config file as YAML which defines the various components to be created/setup when Dartboard runs its commands
• Spin up infrastructure utilizing opentofu/terraform providers
• Setup K3s or RKE2 clusters on the newly created infrastructure
• Deploy Rancher (with or without downstream cluster), rancher-monitoring (Grafana + Prometheus)
• Create resources in-bulk within the newly created Rancher cluster (ConfigMaps, Secrets, Users, Roles, etc.)
• Run various performance and scalability tests via k6
• Export/Import various tracked metrics (WIP)

Given all these features (and the features to come), it can be difficult to onboard and transfer knowledge of the tool. With a TUI, Dartboard's usage complexity can be greatly reduced!

Goals

• Create a TUI for Dartboard's "subcommands"
• Gain more familiarity with Dartboard and create a more user-friendly interface to enable others to use it
• Stretch Create a TUI workflow for generating a Dart file

Resources

https://github.com/charmbracelet/bubbletea

---

Learn enough Golang and hack on CoreDNS by jkuzilek

Description

I'm implementing a split-horizon DNS for my home Kubernetes cluster to be able to access my internal (and external) services over the local network through public domains. I managed to make a PoC with the k8s_gateway plugin for CoreDNS. However, I soon found out it responds with IPs for all Gateways assigned to HTTPRoutes, publishing public IPs as well as the internal Loadbalancer ones.

To remedy this issue, a simple filtering mechanism has to be implemented.

Goals

• Learn an acceptable amount of Golang
• Implement GatewayClass (and IngressClass) filtering for k8s_gateway
• Deploy on homelab cluster
• Profit?

Resources

• https://github.com/ori-edge/k8s_gateway/issues/36
• https://github.com/coredns/coredns/issues/2465#issuecomment-593910983

EDIT: Feature mostly complete. An unfinished PR lies here. Successfully tested working on homelab cluster.

---

terraform-provider-feilong by e_bischoff

Project Description

People need to test operating systems and applications on s390 platform.

Installation from scratch solutions include:

• just deploy and provision manually (with the help of ftpboot script, if you are at SUSE)
• use s3270 terminal emulation (used by openQA people?)
• use LXC from IBM to start CP commands and analyze the results
• use zPXE to do some PXE-alike booting (used by the orthos team?)
• use tessia to install from scratch using autoyast
• use libvirt for s390 to do some nested virtualization on some already deployed z/VM system
• directly install a Linux kernel on a LPAR and use kvm + libvirt from there

Deployment from image solutions include:

• use ICIC web interface (openstack in disguise, contributed by IBM)
• use ICIC from the openstack terraform provider (used by Rancher QA)
• use zvm_ansible to control SMAPI
• connect directly to SMAPI low-level socket interface

IBM Cloud Infrastructure Center (ICIC) harnesses the Feilong API, but you can use Feilong without installing ICIC, provided you set up a "z/VM cloud connector" into one of your VMs following this schema.

What about writing a terraform Feilong provider, just like we have the terraform libvirt provider? That would allow to transparently call Feilong from your main.tf files to deploy and destroy resources on your system/z.

Other Feilong-based solutions include:

• make libvirt Feilong-aware
• simply call Feilong from shell scripts with curl
• use zvmconnector client python library from Feilong
• use zthin part of Feilong to directly command SMAPI.

Goal for Hackweek 23

My final goal is to be able to easily deploy and provision VMs automatically on a z/VM system, in a way that people might enjoy even outside of SUSE.

My technical preference is to write a terraform provider plugin, as it is the approach that involves the least software components for our deployments, while remaining clean, and compatible with our existing development infrastructure.

Goals for Hackweek 24

Feilong provider works and is used internally by SUSE Manager team. Let's push it forward!

Let's add support for fiberchannel disks and multipath.

Goals for Hackweek 25

• Finish support for fiberchannel disks and multipath
• Fix problems with registration on hashicorp providers registry

---

OpenQA Golang api client by hilchev

Description

I would like to make a simple cli tool to communicate with the OpenQA API

Goals

• OpenQA has a ton of information that is hard to get via the UI. A tool like this would make my life easier :)
• Would potentially make it easier in the future to make UI changes without Perl.
• Improve my Golang skills

Resources

• https://go.dev/doc/
• https://openqa.opensuse.org/api

---

toptop - a top clone written in Go by dshah

Description

toptop is a clone of Linux's top CLI tool, but written in Go.

Goals

Learn more about Go (mainly bubbletea) and Linux

Resources

GitHub

---

Hack on rich terminal user interfaces by amanzini

Description

TUIs (Textual User Interface) are a big classic of our daily workflow. Many linux users 'live' in the terminal and modern implementations have a lot to offer : unicode fonts, 24 bit colors etc.

Goals

• Explore the current available solution on modern languages and implement a PoC , for example a small maze generator, porting of a classic game or just display the HackWeek cute logo.
• Practice some Go / Rust coding and programming patterns
• Fiddle around, hack, learn, have fun
• keep a development diary, practice on project documentation

Follow this link for source code repository

• includes development diary

Some ideas for inspiration:

• https://github.com/coding-horror/basic-computer-games
• https://git.imzadi.de/acn/vt100-games
• https://github.com/skx/lighthouse-of-doom
• https://github.com/rothgar/awesome-tuis
• https://www.zq1.de/~bernhard/images/share/geeko/logo.txt

Related projects:

• https://hackweek.opensuse.org/24/projects/suse-rancher-supportconfig from @eminguez

Resources

• Python:

  • https://github.com/Textualize/rich

• Go:

  • https://charm.sh/
  • https://github.com/JoelOtter/termloop
  • https://github.com/gdamore/tcell
  • https://earthly.dev/blog/tui-app-with-go/
  • https://www.inngest.com/blog/interactive-clis-with-bubbletea
  • https://m.youtube.com/watch?v=uJ2egAkSkjg

• Rust:

  • https://ratatui.rs/
  • https://github.com/lemunozm/ruscii
  • https://gitlab.com/thustle/thardians-rs
  • https://www.youtube.com/live/qaaHhfPGde0

• Misc:

  • Book about programming mazes

---

Jenny Static Site Generator by adam.pickering

Description

For my personal site I have been using hugo. It works, but I am not satisfied: every time I want to make a change (which is infrequently) I have to read through the documentation again to understand how hugo works. I don't find the documentation easy to use, and the structure of the repository that hugo requires is unintuitive/more complex than what I need. So, I have decided to write my own simple static site generator in Go. It is named Jenny, after my wife.

Goals

• Pages can be written in markdown (which is automatically converted to HTML), but other file types are also allowed
• Easy to understand and use
  • Intuitive, simple design
  • Clear documentation
  • Hot reloading
  • Binaries provided for download
• Future maintenance is easy
  • Automated releases

Resources

https://github.com/adamkpickering/jenny

---

ddflare: (Dynamic)DNS management via Cloudflare API in Kubernetes by fgiudici

Description

ddflare is a project started a couple of weeks ago to provide DDNS management using v4 Cloudflare APIs: Cloudflare offers management via APIs and access tokens, so it is possible to register a domain and implement a DynDNS client without any other external service but their API.

Since ddflare allows to set any IP to any domain name, one could manage multiple A and ALIAS domain records. Wouldn't be cool to allow full DNS control from the project and integrate it with your Kubernetes cluster?

Goals

Main goals are:

1. add containerized image for ddflare
2. extend ddflare to be able to add and remove DNS records (and not just update existing ones)
3. add documentation, covering also a sample pod deployment for Kubernetes
4. write a ddflare Kubernetes operator to enable domain management via Kubernetes resources (using kubebuilder)

Available tasks and improvements tracked on ddflare github.

Resources

• https://github.com/fgiudici/ddflare
• https://developers.cloudflare.com/api/
• https://book.kubebuilder.io

---

ClusterOps - Easily install and manage your personal kubernetes cluster by andreabenini

Description

ClusterOps is a Kubernetes installer and operator designed to streamline the initial configuration and ongoing maintenance of kubernetes clusters. The focus of this project is primarily on personal or local installations. However, the goal is to expand its use to encompass all installations of Kubernetes for local development purposes.
It simplifies cluster management by automating tasks and providing just one user-friendly YAML-based configuration config.yml.

Overview

• Simplified Configuration: Define your desired cluster state in a simple YAML file, and ClusterOps will handle the rest.
• Automated Setup: Automates initial cluster configuration, including network settings, storage provisioning, special requirements (for example GPUs) and essential components installation.
• Ongoing Maintenance: Performs routine maintenance tasks such as upgrades, security updates, and resource monitoring.
• Extensibility: Easily extend functionality with custom plugins and configurations.
• Self-Healing: Detects and recovers from common cluster issues, ensuring stability, idempotence and reliability. Same operation can be performed multiple times without changing the result.
• Discreet: It works only on what it knows, if you are manually configuring parts of your kubernetes and this configuration does not interfere with it you can happily continue to work on several parts and use this tool only for what is needed.

Features

• distribution and engine independence. Install your favorite kubernetes engine with your package manager, execute one script and you'll have a complete working environment at your disposal.
  
• Basic config approach. One single config.yml file with configuration requirements (add/remove features): human readable, plain and simple. All fancy configs managed automatically (ingress, balancers, services, proxy, ...).
• Local Builtin ContainerHub. The default installation provides a fully configured ContainerHub available locally along with the kubernetes installation. This configuration allows the user to build, upload and deploy custom container images as they were provided from external sources. Internet public sources are still available but local development can be kept in this localhost server. Builtin ClusterOps operator will be fetched from this ContainerHub registry too.
• Kubernetes official dashboard installed as a plugin, others planned too (k9s for example).
• Kubevirt plugin installed and properly configured. Unleash the power of classic virtualization (KVM+QEMU) on top of Kubernetes and manage your entire system from there, libvirtd and virsh libs are required.
• One operator to rule them all. The installation script configures your machine automatically during installation and adds one kubernetes operator to manage your local cluster. From there the operator takes care of the cluster on your behalf.
• Clean installation and removal. Just test it, when you are done just use the same program to uninstall everything without leaving configs (or pods) behind.

Planned features (Wishlist / TODOs)

• Containerized Data Importer (CDI). Persistent storage management add-on for Kubernetes to provide a declarative way of building and importing Virtual Machine Disks on PVCs for

---