Scylla: A Kubernetes Hydra Implementation in Rust

Scylla is an implementation of the Open App Model (OAM) that allows users to focus on easily deploying and managing applications on any Kubernetes cluster without dealing with the complexities of the orchestrator.

Scylla is currently in alpha. It may reflect the API or features we are vetting before inclusion into the Open App Model spec..

Quickstart: Deploy an app with Ingress

1. Ensure you have a Kubernetes cluster.

   • Azure Kubernetes Service
   • Alibaba Kubernetes Service
   • Google Kubernetes Engine
   • Elastic Kubernetes Service
   • Minikube

2. Install kubectl.

   curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/darwin/amd64/kubectl"

3. Install helm. The below is copied directly from the Helm installation guide.

   1. Download your desired version
   2. Unpack it (tar -zxvf helm-v2.0.0-linux-amd64.tgz)
   3. Find the helm binary in the unpacked directory, and move it to its desired destination (mv linux-amd64/helm /usr/local/bin/helm)
   4. From there, you should be able to run the client: helm help.

4. Clone this repository.

   git clone https://github.com/microsoft/scylla.git

5. Install Scylla on the cluster.

   helm install scylla ./charts/scylla --wait

6. Install NGINX ingress on your cluster. Currently, Scylla does take any opinions on how to accomplish tasks but rather leverages existing components.

   helm install stable/nginx-ingress

7. Register the components on your cluster.

   kubectl apply -f examples/nginx-component.yaml

8. Apply the configuration to add the Ingress trait to your component.

   kubectl apply -f examples/first-app-config.yaml

The Problem Space: Building cloud native applications is difficult

Users want to focus on describing and building applications but Kubernetes is complex. At the heart of it, Kubernetes exposes container infrastructure primitives. Users have to stitch these together to accomplish their business goals.

While Kubernetes makes container management easier, the requirement to understand all the container infrastructure has introduced the following problems:

• There is no standard definiton for a cloud native application which makes it difficult for users looking for an easier way to modernize.
• There are myriad of tools and ways to accomplish tasks. On one hand, this is positive because it gives users the freedom to choose their own path. However, for users looking for an opinionated way to do things, there is an opportunity.
• It is difficult to have a clear separation of roles between infra operators, app operators and developers. Users are exposed to constructs out of their domain that they have to learn to accomplish day-to-day tasks.

The approach: Let's take things one step at a time

Scylla takes an incremental approach to solving the problems. The current implementation is a layer on Kubernetes which allows OAM specifications to be deployed on Kubernetes clusters using familiar Kube APIs (you can still use kubectl!).

• This allows app developers to focus on building OAM components, app operators to focus on operational capabilities through the OAM app config and infra operators to focus on K8s.

• By leveraging the Open App Model, users now have a framework to define their apps on their Kubernetes clusters.

• Currently, Scylla makes no opinions on the tools to use to accomplish tasks. In the example above, users had to install an Ingress and Scylla would configure it. In the future, this might be an area of focus for improvement.

Try things out yourself

Get started with the Quick Start guide or read the documentation list for more options.

Contributing

This project welcomes contributions and suggestions. See CONTRIBUTING.md for more details. Below are links to join the bi-weekly community meetings and our meeting notes. Community Slack channels & mailing lists will be added shortly (~ 10/1).

Item	Value
Mailing List	TBD
Meeting Information	Bi-weekly (Starting Sept 24th), Tuesdays 10:30AM PST
Meeting Link	https://zoom.us/j/623691799?pwd=ZWc4SHFNdWpRUVVNYkdJWE9zVHpjZz09
Slack Channel	TBD
Meeting Notes	https://docs.google.com/document/d/1nqdFEyULekyksFHtFvgvFAYE-0AMHKoS3RMnaKsarjs/edit?usp=sharing

Governance

This project follows governance structure of numerous other open source projects. See governance.md for more details.

About the Name

Scylla is one of the monsters in Homer's Odyssey. Odysseus must steer his ship between Scylla and Charybdis. Scylla is sometimes portrayed as a hydra.

Why Rust?

On occasion, we have been asked why Scylla is written in Rust instead of Go. There is no requirement in the Kubernetes world that Kubernetes controllers be written in Go. Many languages implement the Kubernetes API and can be used for creating controllers. We decided to write Scylla in Rust because the language allows us to write Kubernetes controllers with far less code. Rust's generics make it possible to quickly and succinctly describe custom Kubernetes API resources without requiring developers to run code generators. And Rust's Kubernetes library can easily switch between Kubernetes versions with ease. We recognize that Rust might not be to everyone's taste (and neither is Go). However, we are confident that Rust is a solid choice for writing maintainable and concise Kubernetes applications.

License

This project is available under the terms of the MIT license. See LICENSE.txt.