Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
KubeSlice currently uses a full-mesh topology for the slice overlay network, where every cluster connects to every other cluster in the slice. This results in unnecessary tunnel creation and resource consumption. This project proposes a topology-aware design, allowing users to define custom connectivity matrices for slices. Users can specify partial meshes. Additionally, the project will support configuring each cluster's VPN deployment type (client/server) to accommodate network constraints such as firewalls or NAT. Expected Outcome: 1. Extension of the Slice CRD to support custom topology and VPN role definitions. 2. Logic to establish tunnels based only on the defined connectivity matrix. 3. Support for various deployment topologies (full-mesh, partial mesh, hub-spoke). 4. Sample configurations and documentation on how to define and validate topologies.
We intend to get some help around open issues in the repository and also come up with new use cases and scenarios for performance testing any kubernetes distribution. We love new perspectives and are always open to new ideas alongside what we have as tracked work in github issues. Expected Outcome: To knock down some of open critical issues and bring in new perspective to the project. There are no restrictions while working with issues/enhancements.
Volcano dashboard is a volcano resource front-end display tool. Currently, it only supports viewing resources, and the resources displayed are limited. It needs to support viewing more resources, and supports operations such as creation and deletion. Expected Outcome: 1. Supports viewing resources other than volcano related resources. 2. Supports add, delete, modify and query resources such as queues and volcano jobs.
Inspektor Gadget is an eBPF tool and systems inspection framework for Kubernetes, containers and Linux hosts. A Gadget is an OCI image that includes one or more eBPF programs, metadata YAML file, and optionally, WASM modules for post processing. As OCI images, they use the same tooling as containers: building, pushing/pulling from OCI Registries. Even though there are many integration tests, we wish to increase the coverage of unit tests for the majority of internal packages. These packages are essential, and a bad commit could lead to unseen disruptions. Debugging and diagnosing through integration tests is cumbersome and takes too much time. Expected Outcome: 1) Find out which packages are in most need of unit tests 2) Create a mock class/framework if needed 3) Implement unit tests
Currently Antrea uses a third-party tool called [bincover](https://github.com/confluentinc/bincover) to measure code coverage when running end-to-end (e2e) tests. This tool has been deprecated in favor of the built-in Go coverage profiling tool (https://go.dev/testing/coverage/) starting with Go 1.20, and it is no longer maintained. We would like to remove usage of bincover from the Antrea project and start using the built-in Go tool. Expected Outcome: Complete removal of the bincove dependency. Code coverage can still be measured with the same accuracy when running Antrea e2e tests and the results can still be reported to [Codecov](https://about.codecov.io/).
Kyverno 1.14 is introducing new policy types based on the upstream Kubernetes ValidatingAdmissionPolicy and MutatingAdmissionPolicy resources, as well as a new ImageVerificationPolicy based on CEL. This project will focus on the website and sample policy updates using the new policy types.
Using tried and true processes and tools, modernize a legacy COBOL application to take advantage of cloud, APIs and micro services. Document the process and results, enabling others to modernize their legacy COBOL applications.
WasmEdge is a WebAssembly runtime in both interpreter and ahead-of-time mode. However, WasmEdge only supports the binary format for the input WebAssembly file. To help the text format WebAssembly loader feature in the future, the implementation of serializing a WebAssembly module is necessary. In this mentorship, we hope the mentee should complete the serialization functions already in [the `dev/serialize` branch](https://github.com/WasmEdge/WasmEdge/tree/dev/serialize) of the `WasmEdge` repo. - Expected outcome: Complete the serialization functions of WebAssembly modules, such as the element segment and data segment encoding. Complete the WebAssembly instructions encoding. Generate the unit test data and pass the unit tests. >80% of code coverage for serialization.
Enhance Meshery's existing orchestration capabilities to include support for kro ResourceGraphDefinitions (RGDs) as first-class Meshery Models (https://docs.meshery.io/concepts/logical/models). This involves enabling Meshery to manage and orchestrate RGDs, similar to how it handles other Kubernetes resources. The project will also include generating support for ResourceGraphDefinition in Meshery's Model generator. Expected Outcome: Meshery will be able to orchestrate and manage kro RGDs. This includes the ability to deploy, configure, and manage the lifecycle of RGDs through Meshery. The Meshery Model generator will be updated to automatically generate models for kro RGDs, simplifying their integration and management within Meshery. This will be an officially supported feature of Meshery.
Kubescape's control library includes more than 200 controls, tests that codify Kubernetes best practices derived from the most prevalent security frameworks in the industry. Metadata in the controls is used to generate documentation pages in the ARMO website. This project will update this automation to make this control documentation available on kubescape.io. - Expected Outcome: A full set of documentation for Kubescape controls on kubescape.io. Stretch goals include better README-style documentation inside the repository, and documentation pages on how the controls, frameworks and tests relate.
Description: historically, the Jaeger backend used the OpenTracing API, with Jaeger's own Go SDK `jaeger-client-go`, for instrumenting its own internals for distributed tracing. Since Jaeger's SDKs have been deprecated, we want to upgrade the Jaeger backend to use the OpenTelemetry tracing API and SDK directly. - Expected Outcome: - Replace the use of OpenTracing API with OpenTelemetry - Remove `jaeger-client-go` and `jaeger-lib` as dependencies - Remove `opentracing-go` and `opentracing-contrib/*` as dependencies - Switch to standard instrumentation libraries where available (e.g. for HTTP, gRPC) - Rethink/rework `crossdock` integration tests to test end-to-end flow with OpenTelemetry data - Publish a blog post on medium.com/jaegertracing documenting the experience
Kyverno is a Kubernetes native policy manager that can be used in place of PodSecurityPolicies. OpenEBS helm charts currently set up PSPs for many of its Storage engines. This project is to convert PSPs into corresponding Kyverno policies. The OpenEBS storage engines also uses a custom admission webhook validator. The scope of the project can extend to replacing the custom validators with Kyverno policies.
Jaeger is a distributed tracing platform. Jaeger V2 is a major new version where we rebase all Jaeger backend components (agent, collector, ingester, and query) on top of the OpenTelemetry Collector. Jaeger-v1 collector can serve sampling configuration to SDKs, and allows either static configuration (with hot reload) or adaptive sampling that continuously re-calculates the desired sampling probabilities. We need to enable all these capabilities in jaeger-v2. Expected Outcome: Support adaptive sampling in jaeger-v2
Hyperledger Cello aims to simplify the deployment and management of blockchain technology across various industries, offering a robust toolkit for creating, managing, and monitoring blockchain networks on demand. Currently, the project is facing an upgrade to Hyperledger Fabric version 2.5 LTS. This upgrade is critical for enhancing the platform's stability, security, and performance, addressing current limitations and opening new avenues for blockchain applications. Interns will contribute directly to Hyperledger Cello by addressing GitHub issues and enhancing the project's features and documentation. Their work will improve the ease of blockchain network management, making blockchain technology more accessible and efficient for users. A significant part of the mentorship involves upgrading Hyperledger Cello to support Hyperledger Fabric version 2.5 LTS. This includes integrating new features, ensuring compatibility, and contributing to the overall stability and performance of blockchain solutions deployed via Cello.
Support specifying the deletion propagation policy in cleanup policies and TTL-based cleanup. Expected Outcome: 1. Support specifying the deletion propagation policy in cleanup policies 2. Support specifying the deletion propagation policy with TTL-based cleanup
Since permissioned blockchain has been adopted widely in various industries, the need to integrate different permissioned blockchains rises up recently. The two core problems of this case are chain contract interoperability and transaction atomic. Many frameworks and solutions proposed currently are a bit complex. We introduced a lightweight protocol and reference implementation inspired by the ‘ServiceMesh’ pattern in the microservice integration area. Combine with a stateless off-chain relay and an extended on-chain contract development kit as a ‘SideCar’ for different permissioned blockchains. Contract developers can focus on writing business logic since the on-chain contract development kit uses an AOP(aspect-oriented programming) approach to delegate the contract interoperability. In addition it also provides a lock API for locking contract state which can be used in two-phase commit cases. The off-chain relay uses an event based architecture to coordinate different permissioned blockchains. Learning Outcome 1) Implement the on-chain contract development kit for Hyperledger fabric using JAVA. 2) Implement the on-chain contract development kit for Consensys quorum or Hyperledger Besu using Solidity. 3) Implement the off-chain relay plugin for Consensys quorum or Hyperledger Besu.
In KubeVela, we use [CUElang](https://cuelang.org/) to code the X-Definition. We want to support auto generation of multiple languages SDK from CUE, so that users can buidling KubeVela Application in their own language. This helps to adoptors to build platform based on KubeVela. - Expected Outcome: Support auto generation of multiple languages SDK from CUE, including Java, Typescript ,Python. This capability should be part of vela CLI command.
Jaeger has always supported Elasticsearch (ES) as an official backend. Unfortunately, the Go driver we are using, `olivere/elastic`, does not support ESv8 and not planning to release any new versions. Despite the licensing changes, Elasticsearch remains a popular choice and v8 support question often comes up. In this project we want to add official support for ESv8. However, we also want to take this opportunity to do a better alignment with the OpenTelemetry Collector, which already has an [ESv8 exporter](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/elasticsearchexporter), perhaps we can use it directly and minimize the amount of code. - Expected Outcomes: - Use OTEL ESv8 exporter from Jaeger, if possible, otherwise build internal implementation - Stretch goal: use ES data as the source for Jaeger SPM views
- Description: KubeVela currently have a variety of addons , including experimental options, that address scenarios such as Continual Delivery and observability. To further enhance the out-of-box functionality for users of KubeVela, we can offer additional useful addons. - Expected Outcome: 10+ eperimetal addons, clear documentation should be provided for enabling and using these addons, including examples of useful use-cases.
In this project, we aim to build a Rust-based log processing framework. Applications built on this framework will be compiled into WebAssembly and run in WasmEdge containers side by side with Linux containers and apps. The WasmEdge app collects logs from other containerized apps and then sends them to a streaming database or processing pipeline. - Expected outcome: * Create a Rust framework with 3 traits similar to the [`Transformer`](https://github.com/second-state/MEGA/blob/main/mega_etl/src/lib.rs#L99) trait in the [MEGA framework](https://github.com/second-state/MEGA). * The `Collector` trait abstracts operations needed for a log collector. * The `Transformer` trait abstracts the transformation algorithms that can be applied to the logs. * The `Destination` trait abstracts operations needed to send transformed to a streaming data pipeline or database. * Implement at least two `Collector`s. One for MySQL database binlog and the other for a generic log file in a Linux container in the same Kubernetes pod. * Implement at least two `Transformer` algorithms supported by [FileBeat](https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html). * Implement at least three `Destination`s. One for a Kafka queue, one for a Redis database, and the other for ElasticSearch. * Provide CI and demo test cases. * Provide documentation and tutorials.
KWOK (Kubernetes WithOut Kubelet) is a toolkit that enables setting up a cluster of thousands of Nodes in seconds. On the KWOK homepage (https://kwok.sigs.k8s.io/), we aim to document the technical outcomes of using KWOK. These outcomes represent the aggregation of some of KWOK's features to achieve a high-level technical goal. Currently, we have the following areas of focus: Chaos Testing, Performance, Simulation, and Scalability. Expected Outcome: A section of the KWOK website detailing these technical outcomes.
Meshery CLI is a powerful tool to manage all your cloud native resources, Meshery has internal capability called Registry to store and manage models, categories, component and relationship, presently Meshery’s v0.7 release allow users to view all this information from Mehery UI. We also need to expose Meshery’s registry capability through mesheryctl Expected Outcome: Design mesheryctl subcommands and flags for registering, listing, retrieving, updating, and deleting models, components and relationships. Implement validation and error handling for user input and API responses. Integrate with relevant Meshery APIs to interact with the registry backend.
We want to expand the scope of the CloudNativePG tests, introducing a full-fledged chaos testing framework that can be used to better validate the resilience, fault tolerance and recovery mechanisms of CloudNativePG. Expected Outcome: 1. Selection of a Kubernetes-native chaos testing framework (e.g., LitmusChaos or Chaos Mesh). 2. Design and automation of an initial set of chaos experiments covering common failure scenarios. 3. Integration of these experiments into CI/CD to ensure reproducible testing. 4. Collection of clear observability metrics (e.g., failover time, data consistency) to assess resilience and recovery. 5. Documentation and guidelines to help contributors create and run new chaos experiments safely.
Cluster API Provider AWS (CAPA) enables the creation of Kubernetes clusters in AWS with Cluster API. With increasing adoption of Cluster API (CAPI) in general and of CAPA we want to improve the supportability of CAPA, especially for production environments. The first part of this is to add telemetry/tracing using OpenTelemetry so that we can understand and visualize the flow of reconciliation within the provider. This will enable the project and its end users to understand the behavior of reconciliation (including API services called) and will help diagnose issues and performance problems. Expected Outcome: An implementation of OpenTelemetry in CAPA with associated documentation that has been released in a new version of CAPA.